Class OcpClient

buildCreateOcfObjectCommand: (
    params: CreateOcfObjectParams,
) => CommandWithDisclosedContracts[]

client: LedgerJsonApiClient

companyValuationReport: {
    addObserversToCompanyValuationReport: (
        params: { added: string[]; companyValuationReportContractId: string },
    ) => Promise<{ contractId: string; updateId: string }>;
    buildCreateCompanyValuationReportCommand: (
        params: CreateCompanyValuationReportParams,
    ) => CommandWithDisclosedContracts;
    createCompanyValuationReport: (
        params: CreateCompanyValuationReportParams,
    ) => Promise<CreateCompanyValuationReportResult>;
    updateCompanyValuationReport: (
        params: UpdateCompanyValuationParams,
    ) => Promise<UpdateCompanyValuationResult>;
}

convertibleIssuance: {
    buildArchiveConvertibleIssuanceByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateConvertibleIssuanceCommand: (
        params: CreateConvertibleIssuanceParams,
    ) => CommandWithDisclosedContracts;
    getConvertibleIssuanceAsOcf: (
        params: GetConvertibleIssuanceAsOcfParams,
    ) => Promise<GetConvertibleIssuanceAsOcfResult>;
}

document: {
    buildArchiveDocumentByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateDocumentCommand: (
        params: CreateDocumentParams,
    ) => CommandWithDisclosedContracts;
    getDocumentAsOcf: (
        params: GetDocumentAsOcfParams,
    ) => Promise<GetDocumentAsOcfResult>;
}

issuer: {
    buildArchiveIssuerByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateIssuerCommand: (
        params: CreateIssuerParams,
    ) => CommandWithDisclosedContracts;
    getIssuerAsOcf: (
        params: GetIssuerAsOcfParams,
    ) => Promise<GetIssuerAsOcfResult>;
}

issuerAuthorization: {
    authorizeIssuer: (
        params: AuthorizeIssuerParams,
    ) => Promise<AuthorizeIssuerResult>;
    withdrawAuthorization: (
        params: WithdrawAuthorizationParams,
    ) => Promise<WithdrawAuthorizationResult>;
}

issuerAuthorizedSharesAdjustment: {
    buildArchiveIssuerAuthorizedSharesAdjustmentByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateIssuerAuthorizedSharesAdjustmentCommand: (
        params: CreateIssuerAuthorizedSharesAdjustmentParams,
    ) => CommandWithDisclosedContracts;
    getIssuerAuthorizedSharesAdjustmentEventAsOcf: (
        params: GetIssuerAuthorizedSharesAdjustmentEventAsOcfParams,
    ) => Promise<GetIssuerAuthorizedSharesAdjustmentEventAsOcfResult>;
}

stakeholder: {
    buildArchiveStakeholderByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStakeholderCommand: (
        params: CreateStakeholderParams,
    ) => CommandWithDisclosedContracts;
    getStakeholderAsOcf: (
        params: GetStakeholderAsOcfParams,
    ) => Promise<GetStakeholderAsOcfResult>;
}

stockCancellation: {
    buildArchiveStockCancellationByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockCancellationCommand: (
        params: CreateStockCancellationParams,
    ) => CommandWithDisclosedContracts;
    getStockCancellationEventAsOcf: (
        params: GetStockCancellationEventAsOcfParams,
    ) => Promise<GetStockCancellationEventAsOcfResult>;
}

stockClass: {
    buildArchiveStockClassByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockClassCommand: (
        params: CreateStockClassParams,
    ) => CommandWithDisclosedContracts;
    getStockClassAsOcf: (
        params: GetStockClassAsOcfParams,
    ) => Promise<GetStockClassAsOcfResult>;
}

stockClassAuthorizedSharesAdjustment: {
    buildArchiveStockClassAuthorizedSharesAdjustmentByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockClassAuthorizedSharesAdjustmentCommand: (
        params: CreateStockClassAuthorizedSharesAdjustmentParams,
    ) => CommandWithDisclosedContracts;
    getStockClassAuthorizedSharesAdjustmentEventAsOcf: (
        params: GetStockClassAuthorizedSharesAdjustmentEventAsOcfParams,
    ) => Promise<GetStockClassAuthorizedSharesAdjustmentEventAsOcfResult>;
}

stockIssuance: {
    buildArchiveStockIssuanceByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockIssuanceCommand: (
        params: CreateStockIssuanceParams,
    ) => CommandWithDisclosedContracts;
    getStockIssuanceAsOcf: (
        params: GetStockIssuanceAsOcfParams,
    ) => Promise<GetStockIssuanceAsOcfResult>;
}

stockLegendTemplate: {
    buildArchiveStockLegendTemplateByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockLegendTemplateCommand: (
        params: CreateStockLegendTemplateParams,
    ) => CommandWithDisclosedContracts;
    getStockLegendTemplateAsOcf: (
        params: GetStockLegendTemplateAsOcfParams,
    ) => Promise<GetStockLegendTemplateAsOcfResult>;
}

stockPlan: {
    buildArchiveStockPlanByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateEquityCompensationExerciseCommand: (
        params: CreateEquityCompensationExerciseParams,
    ) => CommandWithDisclosedContracts;
    buildCreateEquityCompensationIssuanceCommand: (
        params: CreateEquityCompensationIssuanceParams,
    ) => CommandWithDisclosedContracts;
    buildCreateStockPlanCommand: (
        params: CreateStockPlanParams,
    ) => CommandWithDisclosedContracts;
    getEquityCompensationExerciseEventAsOcf: (
        params: GetEquityCompensationExerciseEventAsOcfParams,
    ) => Promise<GetEquityCompensationExerciseEventAsOcfResult>;
    getEquityCompensationIssuanceEventAsOcf: (
        params: GetEquityCompensationIssuanceEventAsOcfParams,
    ) => Promise<GetEquityCompensationIssuanceEventAsOcfResult>;
    getStockPlanAsOcf: (
        params: GetStockPlanAsOcfParams,
    ) => Promise<GetStockPlanAsOcfResult>;
}

stockPlanPoolAdjustment: {
    buildArchiveStockPlanPoolAdjustmentByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateStockPlanPoolAdjustmentCommand: (
        params: CreateStockPlanPoolAdjustmentParams,
    ) => CommandWithDisclosedContracts;
    getStockPlanPoolAdjustmentEventAsOcf: (
        params: GetStockPlanPoolAdjustmentEventAsOcfParams,
    ) => Promise<GetStockPlanPoolAdjustmentEventAsOcfResult>;
}

vestingTerms: {
    buildArchiveVestingTermsByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateVestingTermsCommand: (
        params: CreateVestingTermsParams,
    ) => CommandWithDisclosedContracts;
    getVestingTermsAsOcf: (
        params: GetVestingTermsAsOcfParams,
    ) => Promise<GetVestingTermsAsOcfResult>;
}

warrantIssuance: {
    buildArchiveWarrantIssuanceByIssuerCommand: (
        params: { contractId: string },
    ) =>
        | {
            CreateCommand: {
                createArguments: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                templateId: string;
            };
        }
        | {
            ExerciseCommand: {
                choice: string;
                choiceArgument: z.ZodRecord<
                    z.ZodString,
                    z.ZodUnion<
                        readonly [
                            z.ZodString,
                            z.ZodNumber,
                            z.ZodBoolean,
                            z.ZodNull,
                            z.ZodRecord<z.ZodString, z.ZodAny>,
                            z.ZodArray<z.ZodAny>,
                        ],
                    >,
                >;
                contractId: string;
                templateId: string;
            };
        };
    buildCreateWarrantIssuanceCommand: (
        params: CreateWarrantIssuanceParams,
    ) => CommandWithDisclosedContracts;
    getWarrantIssuanceAsOcf: (
        params: GetWarrantIssuanceAsOcfParams,
    ) => Promise<GetWarrantIssuanceAsOcfResult>;
}