@canton-network/core-token-standard 0.9.0 → 0.11.0

package/dist/index.d.ts

@@ -1,4 +1,1640 @@
-export * from './token-standard-client.js';
-export * from './interface-ids.const.js';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map
+import { Logger, AccessTokenProvider, PartyId } from '@canton-network/core-types';
+import * as damlTypes from '@daml/types';
+export { ContractId, Date, Int, Map, Numeric, Optional, Party, Serializable, Time } from '@daml/types';
+
+interface paths$4 {
+    '/registry/allocations/v1/{allocationId}/choice-contexts/execute-transfer': {
+        /** @description Get the choice context to execute a transfer on an allocation. */
+        post: operations$3['getAllocationTransferContext'];
+    };
+    '/registry/allocations/v1/{allocationId}/choice-contexts/withdraw': {
+        /** @description Get the choice context to withdraw an allocation. */
+        post: operations$3['getAllocationWithdrawContext'];
+    };
+    '/registry/allocations/v1/{allocationId}/choice-contexts/cancel': {
+        /** @description Get the choice context to cancel an allocation. */
+        post: operations$3['getAllocationCancelContext'];
+    };
+}
+interface components$3 {
+    schemas: {
+        /** @description A request to get the context for executing a choice on a contract. */
+        GetChoiceContextRequest: {
+            /**
+             * @description Metadata that will be passed to the choice, and should be incorporated
+             * into the choice context. Provided for extensibility.
+             */
+            meta?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description The context required to exercise a choice on a contract via an interface.
+         * Used to retrieve additional reference date that is passed in via disclosed contracts,
+         * which are in turn referred to via their contract ID in the `choiceContextData`.
+         */
+        ChoiceContext: {
+            /** @description The additional data to use when exercising the choice. */
+            choiceContextData: Record<string, never>;
+            /**
+             * @description The contracts that are required to be disclosed to the participant node for exercising
+             * the choice.
+             */
+            disclosedContracts: components$3['schemas']['DisclosedContract'][];
+        };
+        DisclosedContract: {
+            templateId: string;
+            contractId: string;
+            createdEventBlob: string;
+            /**
+             * @description The synchronizer to which the contract is currently assigned.
+             * If the contract is in the process of being reassigned, then a "409" response is returned.
+             */
+            synchronizerId: string;
+            /**
+             * @description The name of the Daml package that was used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPackageName?: string;
+            /**
+             * @description The contract arguments that were used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPayload?: Record<string, never>;
+            /**
+             * Format: date-time
+             * @description The ledger effective time at which the contract was created.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugCreatedAt?: string;
+        };
+        ErrorResponse: {
+            error: string;
+        };
+    };
+    responses: {
+        /** @description bad request */
+        400: {
+            content: {
+                'application/json': components$3['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description not found */
+        404: {
+            content: {
+                'application/json': components$3['schemas']['ErrorResponse'];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations$3 {
+    /** @description Get the choice context to execute a transfer on an allocation. */
+    getAllocationTransferContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the allocation whose transfer the caller wants to execute. */
+                allocationId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components$3['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$3['schemas']['ChoiceContext'];
+                };
+            };
+            400: components$3['responses']['400'];
+            404: components$3['responses']['404'];
+        };
+    };
+    /** @description Get the choice context to withdraw an allocation. */
+    getAllocationWithdrawContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the allocation to withdraw. */
+                allocationId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components$3['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$3['schemas']['ChoiceContext'];
+                };
+            };
+            400: components$3['responses']['400'];
+            404: components$3['responses']['404'];
+        };
+    };
+    /** @description Get the choice context to cancel an allocation. */
+    getAllocationCancelContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the allocation to cancel. */
+                allocationId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components$3['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$3['schemas']['ChoiceContext'];
+                };
+            };
+            400: components$3['responses']['400'];
+            404: components$3['responses']['404'];
+        };
+    };
+}
+
+interface paths$3 {
+    '/registry/allocation-instruction/v1/allocation-factory': {
+        /** @description Get the factory and choice context for creating allocations using the `AllocationFactory_Allocate` choice. */
+        post: operations$2['getAllocationFactory'];
+    };
+}
+interface components$2 {
+    schemas: {
+        GetFactoryRequest: {
+            /**
+             * @description The arguments that are intended to be passed to the choice provided by the factory.
+             * To avoid repeating the Daml type definitions, they are specified as JSON objects.
+             * However the concrete format is given by how the choice arguments are encoded using the Daml JSON API
+             * (with the `extraArgs.context` and `extraArgs.meta` fields set to the empty object).
+             *
+             * The choice arguments are provided so that the registry can also provide choice-argument
+             * specific contracts, e.g., the configuration for a specific instrument-id.
+             */
+            choiceArguments: Record<string, never>;
+            /**
+             * @description If set to true, the response will not include debug fields.
+             * @default false
+             */
+            excludeDebugFields?: boolean;
+        };
+        /**
+         * @description A factory contract together with the choice context required to exercise the choice
+         * provided by the factory. Typically used to implement the generic initiation of on-ledger workflows
+         * via a Daml interface.
+         *
+         * Clients SHOULD avoid reusing the same `FactoryWithChoiceContext` for exercising multiple choices,
+         * as the choice context MAY be specific to the choice being exercised.
+         */
+        FactoryWithChoiceContext: {
+            /** @description The contract ID of the contract implementing the factory interface. */
+            factoryId: string;
+            choiceContext: components$2['schemas']['ChoiceContext'];
+        };
+        /**
+         * @description The context required to exercise a choice on a contract via an interface.
+         * Used to retrieve additional reference date that is passed in via disclosed contracts,
+         * which are in turn referred to via their contract ID in the `choiceContextData`.
+         */
+        ChoiceContext: {
+            /** @description The additional data to use when exercising the choice. */
+            choiceContextData: Record<string, never>;
+            /**
+             * @description The contracts that are required to be disclosed to the participant node for exercising
+             * the choice.
+             */
+            disclosedContracts: components$2['schemas']['DisclosedContract'][];
+        };
+        DisclosedContract: {
+            templateId: string;
+            contractId: string;
+            createdEventBlob: string;
+            /**
+             * @description The synchronizer to which the contract is currently assigned.
+             * If the contract is in the process of being reassigned, then a "409" response is returned.
+             */
+            synchronizerId: string;
+            /**
+             * @description The name of the Daml package that was used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPackageName?: string;
+            /**
+             * @description The contract arguments that were used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPayload?: Record<string, never>;
+            /**
+             * Format: date-time
+             * @description The ledger effective time at which the contract was created.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugCreatedAt?: string;
+        };
+        ErrorResponse: {
+            error: string;
+        };
+    };
+    responses: {
+        /** @description bad request */
+        400: {
+            content: {
+                'application/json': components$2['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description not found */
+        404: {
+            content: {
+                'application/json': components$2['schemas']['ErrorResponse'];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations$2 {
+    /** @description Get the factory and choice context for creating allocations using the `AllocationFactory_Allocate` choice. */
+    getAllocationFactory: {
+        requestBody: {
+            content: {
+                'application/json': components$2['schemas']['GetFactoryRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$2['schemas']['FactoryWithChoiceContext'];
+                };
+            };
+            400: components$2['responses']['400'];
+            404: components$2['responses']['404'];
+        };
+    };
+}
+
+interface paths$2 {
+    '/registry/metadata/v1/info': {
+        /**
+         * @description Get information about the registry.
+         * The response includes the standards supported by the registry.
+         */
+        get: operations$1['getRegistryInfo'];
+    };
+    '/registry/metadata/v1/instruments': {
+        /** @description List all instruments managed by this instrument admin. */
+        get: operations$1['listInstruments'];
+    };
+    '/registry/metadata/v1/instruments/{instrumentId}': {
+        /** @description Retrieve an instrument's metadata. */
+        get: operations$1['getInstrument'];
+    };
+}
+interface components$1 {
+    schemas: {
+        GetRegistryInfoResponse: {
+            /** @description The Daml party representing the registry app */
+            adminId: string;
+            /** @description The token standard APIs supported by the registry. Note that this only includes the registry-wide APIs. Use the instrument lookup endpoints to see which APIs are supported for a given instrument */
+            supportedApis: components$1['schemas']['SupportedApis'];
+        };
+        Instrument: {
+            /** @description The unique identifier assigned by the admin to the instrument. */
+            id: string;
+            /** @description The display name for the instrument recommended by the instrument admin. This is not necessarily unique. */
+            name: string;
+            /** @description The symbol for the instrument recommended by the instrument admin. This is not necessarily unique. */
+            symbol: string;
+            /** @description Decimal encoded current total supply of the instrument. */
+            totalSupply?: string;
+            /**
+             * Format: date-time
+             * @description The timestamp when the total supply was last computed.
+             */
+            totalSupplyAsOf?: string;
+            /**
+             * Format: int8
+             * @description The number of decimal places used by the instrument.
+             *
+             * Must be a number between 0 and 10, as the Daml interfaces represent holding amounts as
+             * `Decimal` values, which use 10 decimal places and are precise for 38 digits.
+             * Setting this to 0 means that the instrument can only be held in whole units.
+             *
+             * This number SHOULD be used for display purposes in a wallet to decide how many
+             * decimal places to show and accept when displaying or entering amounts.
+             *
+             * @default 10
+             */
+            decimals: number;
+            supportedApis: components$1['schemas']['SupportedApis'];
+        };
+        ListInstrumentsResponse: {
+            instruments: components$1['schemas']['Instrument'][];
+            /** @description The token for the next page of results, to be used as the lastInstrumentId for the next page. */
+            nextPageToken?: string;
+        };
+        ErrorResponse: {
+            error: string;
+        };
+        /**
+         * @description Map from token standard API name to the minor version of the API supported, e.g.,
+         * splice-api-token-metadata-v1 -> 1 where the `1` corresponds to the minor version.
+         */
+        SupportedApis: {
+            [key: string]: number;
+        };
+    };
+    responses: {
+        /** @description bad request */
+        400: {
+            content: {
+                'application/json': components$1['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description not found */
+        404: {
+            content: {
+                'application/json': components$1['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description conflict */
+        409: {
+            content: {
+                'application/json': components$1['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description Internal server error */
+        500: {
+            content: {
+                'application/json': components$1['schemas']['ErrorResponse'];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations$1 {
+    /**
+     * @description Get information about the registry.
+     * The response includes the standards supported by the registry.
+     */
+    getRegistryInfo: {
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$1['schemas']['GetRegistryInfoResponse'];
+                };
+            };
+            404: components$1['responses']['404'];
+            500: components$1['responses']['500'];
+        };
+    };
+    /** @description List all instruments managed by this instrument admin. */
+    listInstruments: {
+        parameters: {
+            query?: {
+                /** @description Number of instruments per page. */
+                pageSize?: number;
+                /** @description The `nextPageToken` received from the response for the previous page. */
+                pageToken?: string;
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$1['schemas']['ListInstrumentsResponse'];
+                };
+            };
+            404: components$1['responses']['404'];
+            500: components$1['responses']['500'];
+        };
+    };
+    /** @description Retrieve an instrument's metadata. */
+    getInstrument: {
+        parameters: {
+            path: {
+                instrumentId: string;
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components$1['schemas']['Instrument'];
+                };
+            };
+            404: components$1['responses']['404'];
+            500: components$1['responses']['500'];
+        };
+    };
+}
+
+interface paths$1 {
+    '/registry/transfer-instruction/v1/transfer-factory': {
+        /** @description Get the factory and choice context for executing a direct transfer. */
+        post: operations['getTransferFactory'];
+    };
+    '/registry/transfer-instruction/v1/{transferInstructionId}/choice-contexts/accept': {
+        /** @description Get the choice context to accept a transfer instruction. */
+        post: operations['getTransferInstructionAcceptContext'];
+    };
+    '/registry/transfer-instruction/v1/{transferInstructionId}/choice-contexts/reject': {
+        /** @description Get the choice context to reject a transfer instruction. */
+        post: operations['getTransferInstructionRejectContext'];
+    };
+    '/registry/transfer-instruction/v1/{transferInstructionId}/choice-contexts/withdraw': {
+        /** @description Get the choice context to withdraw a transfer instruction. */
+        post: operations['getTransferInstructionWithdrawContext'];
+    };
+}
+interface components {
+    schemas: {
+        GetFactoryRequest: {
+            /**
+             * @description The arguments that are intended to be passed to the choice provided by the factory.
+             * To avoid repeating the Daml type definitions, they are specified as JSON objects.
+             * However the concrete format is given by how the choice arguments are encoded using the Daml JSON API
+             * (with the `extraArgs.context` and `extraArgs.meta` fields set to the empty object).
+             *
+             * The choice arguments are provided so that the registry can also provide choice-argument
+             * specific contracts, e.g., the configuration for a specific instrument-id.
+             */
+            choiceArguments: Record<string, never>;
+            /**
+             * @description If set to true, the response will not include debug fields.
+             * @default false
+             */
+            excludeDebugFields?: boolean;
+        };
+        /** @description A request to get the context for executing a choice on a contract. */
+        GetChoiceContextRequest: {
+            /**
+             * @description Metadata that will be passed to the choice, and should be incorporated
+             * into the choice context. Provided for extensibility.
+             */
+            meta?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description The transfer factory contract together with the choice context required to exercise the choice
+         * provided by the factory. Typically used to implement the generic initiation of on-ledger workflows
+         * via a Daml interface.
+         *
+         * Clients SHOULD avoid reusing the same `FactoryWithChoiceContext` for exercising multiple choices,
+         * as the choice context MAY be specific to the choice being exercised.
+         */
+        TransferFactoryWithChoiceContext: {
+            /** @description The contract ID of the contract implementing the factory interface. */
+            factoryId: string;
+            /**
+             * @description The kind of transfer workflow that will be used:
+             * * `offer`: offer a transfer to the receiver and only transfer if they accept
+             * * `direct`: transfer directly to the receiver without asking them for approval.
+             *   Only chosen if the receiver has pre-approved direct transfers.
+             * * `self`: a self-transfer where the sender and receiver are the same party.
+             *   No approval is required, and the transfer is typically immediate.
+             *
+             * @enum {string}
+             */
+            transferKind: 'self' | 'direct' | 'offer';
+            choiceContext: components['schemas']['ChoiceContext'];
+        };
+        /**
+         * @description The context required to exercise a choice on a contract via an interface.
+         * Used to retrieve additional reference data that is passed in via disclosed contracts,
+         * which are in turn referred to via their contract ID in the `choiceContextData`.
+         */
+        ChoiceContext: {
+            /** @description The additional data to use when exercising the choice. */
+            choiceContextData: Record<string, never>;
+            /**
+             * @description The contracts that are required to be disclosed to the participant node for exercising
+             * the choice.
+             */
+            disclosedContracts: components['schemas']['DisclosedContract'][];
+        };
+        DisclosedContract: {
+            templateId: string;
+            contractId: string;
+            createdEventBlob: string;
+            /**
+             * @description The synchronizer to which the contract is currently assigned.
+             * If the contract is in the process of being reassigned, then a "409" response is returned.
+             */
+            synchronizerId: string;
+            /**
+             * @description The name of the Daml package that was used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPackageName?: string;
+            /**
+             * @description The contract arguments that were used to create the contract.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugPayload?: Record<string, never>;
+            /**
+             * Format: date-time
+             * @description The ledger effective time at which the contract was created.
+             * Use this data only if you trust the provider, as it might not match the data in the
+             * `createdEventBlob`.
+             */
+            debugCreatedAt?: string;
+        };
+        ErrorResponse: {
+            error: string;
+        };
+    };
+    responses: {
+        /** @description bad request */
+        400: {
+            content: {
+                'application/json': components['schemas']['ErrorResponse'];
+            };
+        };
+        /** @description not found */
+        404: {
+            content: {
+                'application/json': components['schemas']['ErrorResponse'];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    /** @description Get the factory and choice context for executing a direct transfer. */
+    getTransferFactory: {
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['GetFactoryRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components['schemas']['TransferFactoryWithChoiceContext'];
+                };
+            };
+            400: components['responses']['400'];
+            404: components['responses']['404'];
+        };
+    };
+    /** @description Get the choice context to accept a transfer instruction. */
+    getTransferInstructionAcceptContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the transfer instruction to accept. */
+                transferInstructionId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components['schemas']['ChoiceContext'];
+                };
+            };
+            400: components['responses']['400'];
+            404: components['responses']['404'];
+        };
+    };
+    /** @description Get the choice context to reject a transfer instruction. */
+    getTransferInstructionRejectContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the transfer instruction to reject. */
+                transferInstructionId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components['schemas']['ChoiceContext'];
+                };
+            };
+            400: components['responses']['400'];
+            404: components['responses']['404'];
+        };
+    };
+    /** @description Get the choice context to withdraw a transfer instruction. */
+    getTransferInstructionWithdrawContext: {
+        parameters: {
+            path: {
+                /** @description The contract ID of the transfer instruction to withdraw. */
+                transferInstructionId: string;
+            };
+        };
+        requestBody: {
+            content: {
+                'application/json': components['schemas']['GetChoiceContextRequest'];
+            };
+        };
+        responses: {
+            /** @description ok */
+            200: {
+                content: {
+                    'application/json': components['schemas']['ChoiceContext'];
+                };
+            };
+            400: components['responses']['400'];
+            404: components['responses']['404'];
+        };
+    };
+}
+
+type paths = paths$4 & paths$2 & paths$1 & paths$3;
+type PostEndpoint = {
+    [Pathname in keyof paths]: paths[Pathname] extends {
+        post: unknown;
+    } ? Pathname : never;
+}[keyof paths];
+type PostRequest<Path extends PostEndpoint> = paths[Path] extends {
+    post: {
+        requestBody: {
+            content: {
+                'application/json': infer Req;
+            };
+        };
+    };
+} ? Req : never;
+type PostResponse<Path extends PostEndpoint> = paths[Path] extends {
+    post: {
+        responses: {
+            200: {
+                content: {
+                    'application/json': infer Res;
+                };
+            };
+        };
+    };
+} ? Res : never;
+type GetEndpoint = {
+    [Pathname in keyof paths]: paths[Pathname] extends {
+        get: unknown;
+    } ? Pathname : never;
+}[keyof paths];
+type GetResponse<Path extends GetEndpoint> = paths[Path] extends {
+    get: {
+        responses: {
+            200: {
+                content: {
+                    'application/json': infer Res;
+                };
+            };
+        };
+    };
+} ? Res : never;
+declare class TokenStandardClient {
+    private readonly client;
+    private readonly logger;
+    private accessTokenProvider;
+    constructor(baseUrl: string, logger: Logger, isAdmin: boolean, accessToken?: string, accessTokenProvider?: AccessTokenProvider);
+    post<Path extends PostEndpoint>(path: Path, body: PostRequest<Path>, params?: {
+        path?: Record<string, string>;
+        query?: Record<string, string>;
+    }): Promise<PostResponse<Path>>;
+    get<Path extends GetEndpoint>(path: Path, params?: {
+        path?: Record<string, string>;
+        query?: Record<string, string>;
+    }): Promise<GetResponse<Path>>;
+    private valueOrError;
+}
+
+declare const ALLOCATION_FACTORY_INTERFACE_ID = "#splice-api-token-allocation-instruction-v1:Splice.Api.Token.AllocationInstructionV1:AllocationFactory";
+declare const ALLOCATION_INSTRUCTION_INTERFACE_ID = "#splice-api-token-allocation-instruction-v1:Splice.Api.Token.AllocationInstructionV1:AllocationInstruction";
+declare const ALLOCATION_REQUEST_INTERFACE_ID = "#splice-api-token-allocation-request-v1:Splice.Api.Token.AllocationRequestV1:AllocationRequest";
+declare const ALLOCATION_INTERFACE_ID = "#splice-api-token-allocation-v1:Splice.Api.Token.AllocationV1:Allocation";
+declare const HOLDING_INTERFACE_ID = "#splice-api-token-holding-v1:Splice.Api.Token.HoldingV1:Holding";
+declare const METADATA_INTERFACE_ID = "#splice-api-token-metadata-v1:Splice.Api.Token.MetadataV1:AnyContract";
+declare const TRANSFER_FACTORY_INTERFACE_ID = "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferFactory";
+declare const TRANSFER_INSTRUCTION_INTERFACE_ID = "#splice-api-token-transfer-instruction-v1:Splice.Api.Token.TransferInstructionV1:TransferInstruction";
+declare const FEATURED_APP_DELEGATE_PROXY_INTERFACE_ID = "#splice-util-featured-app-proxies:Splice.Util.FeaturedApp.DelegateProxy:DelegateProxy";
+
+// Generated from DA/Internal/Template.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+
+declare type Archive = {}
+
+declare const Archive: damlTypes.Serializable<Archive> & {}
+
+// Generated from DA/Time/Types.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+
+declare type RelTime = {
+    microseconds: damlTypes.Int
+}
+
+declare const RelTime: damlTypes.Serializable<RelTime> & {}
+
+// Generated from Splice/Api/Token/MetadataV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface AnyContractInterface {
+    Archive: damlTypes.Choice<
+        AnyContract,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AnyContract, undefined>
+        >
+}
+
+declare type AnyContract =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.MetadataV1:AnyContract'> &
+        AnyContractView
+declare const AnyContract: damlTypes.InterfaceCompanion<
+    AnyContract,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.MetadataV1:AnyContract'
+> &
+    damlTypes.FromTemplate<AnyContract, unknown> &
+    AnyContractInterface
+
+declare type ChoiceExecutionMetadata = {
+    meta: Metadata
+}
+
+declare const ChoiceExecutionMetadata: damlTypes.Serializable<ChoiceExecutionMetadata> & {}
+
+declare type ExtraArgs = {
+    context: ChoiceContext
+    meta: Metadata
+}
+
+declare const ExtraArgs: damlTypes.Serializable<ExtraArgs> & {}
+
+declare type Metadata = {
+    values: { [key: string]: string }
+}
+
+declare const Metadata: damlTypes.Serializable<Metadata> & {}
+
+declare type ChoiceContext = {
+    values: { [key: string]: AnyValue }
+}
+
+declare const ChoiceContext: damlTypes.Serializable<ChoiceContext> & {}
+
+declare type AnyContractView = {}
+
+declare const AnyContractView: damlTypes.Serializable<AnyContractView> & {}
+
+declare type AnyValue =
+    | { tag: 'AV_Text'; value: string }
+    | { tag: 'AV_Int'; value: damlTypes.Int }
+    | { tag: 'AV_Decimal'; value: damlTypes.Numeric }
+    | { tag: 'AV_Bool'; value: boolean }
+    | { tag: 'AV_Date'; value: damlTypes.Date }
+    | { tag: 'AV_Time'; value: damlTypes.Time }
+    | {
+          tag: 'AV_RelTime'
+          value: RelTime
+      }
+    | { tag: 'AV_Party'; value: damlTypes.Party }
+    | { tag: 'AV_ContractId'; value: damlTypes.ContractId<AnyContract> }
+    | { tag: 'AV_List'; value: AnyValue[] }
+    | { tag: 'AV_Map'; value: { [key: string]: AnyValue } }
+
+declare const AnyValue: damlTypes.Serializable<AnyValue> & {}
+
+// Generated from Splice/Api/Token/HoldingV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface HoldingInterface {
+    Archive: damlTypes.Choice<
+        Holding,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<damlTypes.InterfaceCompanion<Holding, undefined>>
+}
+
+declare type Holding =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.HoldingV1:Holding'> &
+        HoldingView
+declare const Holding: damlTypes.InterfaceCompanion<
+    Holding,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.HoldingV1:Holding'
+> &
+    damlTypes.FromTemplate<Holding, unknown> &
+    HoldingInterface
+
+declare type HoldingView = {
+    owner: damlTypes.Party
+    instrumentId: InstrumentId
+    amount: damlTypes.Numeric
+    lock: damlTypes.Optional<Lock>
+    meta: Metadata
+}
+
+declare const HoldingView: damlTypes.Serializable<HoldingView> & {}
+
+declare type Lock = {
+    holders: damlTypes.Party[]
+    expiresAt: damlTypes.Optional<damlTypes.Time>
+    expiresAfter: damlTypes.Optional<RelTime>
+    context: damlTypes.Optional<string>
+}
+
+declare const Lock: damlTypes.Serializable<Lock> & {}
+
+declare type InstrumentId = {
+    admin: damlTypes.Party
+    id: string
+}
+
+declare const InstrumentId: damlTypes.Serializable<InstrumentId> & {}
+
+// Generated from Splice/Api/Token/AllocationV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface AllocationInterface {
+    Archive: damlTypes.Choice<
+        Allocation,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<Allocation, undefined>
+        >
+    Allocation_Withdraw: damlTypes.Choice<
+        Allocation,
+        Allocation_Withdraw,
+        Allocation_WithdrawResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<Allocation, undefined>
+        >
+    Allocation_Cancel: damlTypes.Choice<
+        Allocation,
+        Allocation_Cancel,
+        Allocation_CancelResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<Allocation, undefined>
+        >
+    Allocation_ExecuteTransfer: damlTypes.Choice<
+        Allocation,
+        Allocation_ExecuteTransfer,
+        Allocation_ExecuteTransferResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<Allocation, undefined>
+        >
+}
+
+declare type Allocation =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationV1:Allocation'> &
+        AllocationView
+declare const Allocation: damlTypes.InterfaceCompanion<
+    Allocation,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationV1:Allocation'
+> &
+    damlTypes.FromTemplate<Allocation, unknown> &
+    AllocationInterface
+
+declare type Allocation_WithdrawResult = {
+    senderHoldingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const Allocation_WithdrawResult: damlTypes.Serializable<Allocation_WithdrawResult> & {}
+
+declare type Allocation_CancelResult = {
+    senderHoldingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const Allocation_CancelResult: damlTypes.Serializable<Allocation_CancelResult> & {}
+
+declare type Allocation_ExecuteTransferResult = {
+    senderHoldingCids: damlTypes.ContractId<Holding>[]
+    receiverHoldingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const Allocation_ExecuteTransferResult: damlTypes.Serializable<Allocation_ExecuteTransferResult> & {}
+
+declare type Allocation_Withdraw = {
+    extraArgs: ExtraArgs
+}
+
+declare const Allocation_Withdraw: damlTypes.Serializable<Allocation_Withdraw> & {}
+
+declare type Allocation_Cancel = {
+    extraArgs: ExtraArgs
+}
+
+declare const Allocation_Cancel: damlTypes.Serializable<Allocation_Cancel> & {}
+
+declare type Allocation_ExecuteTransfer = {
+    extraArgs: ExtraArgs
+}
+
+declare const Allocation_ExecuteTransfer: damlTypes.Serializable<Allocation_ExecuteTransfer> & {}
+
+declare type AllocationView = {
+    allocation: AllocationSpecification
+    holdingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const AllocationView: damlTypes.Serializable<AllocationView> & {}
+
+declare type AllocationSpecification = {
+    settlement: SettlementInfo
+    transferLegId: string
+    transferLeg: TransferLeg
+}
+
+declare const AllocationSpecification: damlTypes.Serializable<AllocationSpecification> & {}
+
+declare type TransferLeg = {
+    sender: damlTypes.Party
+    receiver: damlTypes.Party
+    amount: damlTypes.Numeric
+    instrumentId: InstrumentId
+    meta: Metadata
+}
+
+declare const TransferLeg: damlTypes.Serializable<TransferLeg> & {}
+
+declare type SettlementInfo = {
+    executor: damlTypes.Party
+    settlementRef: Reference
+    requestedAt: damlTypes.Time
+    allocateBefore: damlTypes.Time
+    settleBefore: damlTypes.Time
+    meta: Metadata
+}
+
+declare const SettlementInfo: damlTypes.Serializable<SettlementInfo> & {}
+
+declare type Reference = {
+    id: string
+    cid: damlTypes.Optional<
+        damlTypes.ContractId<AnyContract>
+    >
+}
+
+declare const Reference: damlTypes.Serializable<Reference> & {}
+
+// Generated from Splice/Api/Token/AllocationInstructionV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface AllocationFactoryInterface {
+    Archive: damlTypes.Choice<
+        AllocationFactory,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationFactory, undefined>
+        >
+    AllocationFactory_Allocate: damlTypes.Choice<
+        AllocationFactory,
+        AllocationFactory_Allocate,
+        AllocationInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationFactory, undefined>
+        >
+    AllocationFactory_PublicFetch: damlTypes.Choice<
+        AllocationFactory,
+        AllocationFactory_PublicFetch,
+        AllocationFactoryView,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationFactory, undefined>
+        >
+}
+
+declare type AllocationFactory =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationInstructionV1:AllocationFactory'> &
+        AllocationFactoryView
+declare const AllocationFactory: damlTypes.InterfaceCompanion<
+    AllocationFactory,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationInstructionV1:AllocationFactory'
+> &
+    damlTypes.FromTemplate<AllocationFactory, unknown> &
+    AllocationFactoryInterface
+declare interface AllocationInstructionInterface {
+    Archive: damlTypes.Choice<
+        AllocationInstruction,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationInstruction, undefined>
+        >
+    AllocationInstruction_Withdraw: damlTypes.Choice<
+        AllocationInstruction,
+        AllocationInstruction_Withdraw,
+        AllocationInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationInstruction, undefined>
+        >
+    AllocationInstruction_Update: damlTypes.Choice<
+        AllocationInstruction,
+        AllocationInstruction_Update,
+        AllocationInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationInstruction, undefined>
+        >
+}
+
+declare type AllocationInstruction =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationInstructionV1:AllocationInstruction'> &
+        AllocationInstructionView
+declare const AllocationInstruction: damlTypes.InterfaceCompanion<
+    AllocationInstruction,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationInstructionV1:AllocationInstruction'
+> &
+    damlTypes.FromTemplate<AllocationInstruction, unknown> &
+    AllocationInstructionInterface
+
+declare type AllocationInstructionResult_Output =
+    | {
+          tag: 'AllocationInstructionResult_Pending'
+          value: AllocationInstructionResult_Output.AllocationInstructionResult_Pending
+      }
+    | {
+          tag: 'AllocationInstructionResult_Completed'
+          value: AllocationInstructionResult_Output.AllocationInstructionResult_Completed
+      }
+    | { tag: 'AllocationInstructionResult_Failed'; value: {} }
+
+declare const AllocationInstructionResult_Output: damlTypes.Serializable<AllocationInstructionResult_Output> & {
+    AllocationInstructionResult_Pending: damlTypes.Serializable<AllocationInstructionResult_Output.AllocationInstructionResult_Pending>
+    AllocationInstructionResult_Completed: damlTypes.Serializable<AllocationInstructionResult_Output.AllocationInstructionResult_Completed>
+}
+
+declare namespace AllocationInstructionResult_Output {
+    type AllocationInstructionResult_Pending = {
+        allocationInstructionCid: damlTypes.ContractId<AllocationInstruction>
+    }
+} //namespace AllocationInstructionResult_Output
+
+declare namespace AllocationInstructionResult_Output {
+    type AllocationInstructionResult_Completed = {
+        allocationCid: damlTypes.ContractId<Allocation>
+    }
+} //namespace AllocationInstructionResult_Output
+
+declare type AllocationInstructionResult = {
+    output: AllocationInstructionResult_Output
+    senderChangeCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const AllocationInstructionResult: damlTypes.Serializable<AllocationInstructionResult> & {}
+
+declare type AllocationFactory_PublicFetch = {
+    expectedAdmin: damlTypes.Party
+    actor: damlTypes.Party
+}
+
+declare const AllocationFactory_PublicFetch: damlTypes.Serializable<AllocationFactory_PublicFetch> & {}
+
+declare type AllocationFactory_Allocate = {
+    expectedAdmin: damlTypes.Party
+    allocation: AllocationSpecification
+    requestedAt: damlTypes.Time
+    inputHoldingCids: damlTypes.ContractId<Holding>[]
+    extraArgs: ExtraArgs
+}
+
+declare const AllocationFactory_Allocate: damlTypes.Serializable<AllocationFactory_Allocate> & {}
+
+declare type AllocationFactoryView = {
+    admin: damlTypes.Party
+    meta: Metadata
+}
+
+declare const AllocationFactoryView: damlTypes.Serializable<AllocationFactoryView> & {}
+
+declare type AllocationInstruction_Update = {
+    extraActors: damlTypes.Party[]
+    extraArgs: ExtraArgs
+}
+
+declare const AllocationInstruction_Update: damlTypes.Serializable<AllocationInstruction_Update> & {}
+
+declare type AllocationInstruction_Withdraw = {
+    extraArgs: ExtraArgs
+}
+
+declare const AllocationInstruction_Withdraw: damlTypes.Serializable<AllocationInstruction_Withdraw> & {}
+
+declare type AllocationInstructionView = {
+    originalInstructionCid: damlTypes.Optional<
+        damlTypes.ContractId<AllocationInstruction>
+    >
+    allocation: AllocationSpecification
+    pendingActions: damlTypes.Map<damlTypes.Party, string>
+    requestedAt: damlTypes.Time
+    inputHoldingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const AllocationInstructionView: damlTypes.Serializable<AllocationInstructionView> & {}
+
+declare const index_d$8_AllocationFactory: typeof AllocationFactory;
+type index_d$8_AllocationFactoryInterface = AllocationFactoryInterface;
+declare const index_d$8_AllocationFactoryView: typeof AllocationFactoryView;
+declare const index_d$8_AllocationFactory_Allocate: typeof AllocationFactory_Allocate;
+declare const index_d$8_AllocationFactory_PublicFetch: typeof AllocationFactory_PublicFetch;
+declare const index_d$8_AllocationInstruction: typeof AllocationInstruction;
+type index_d$8_AllocationInstructionInterface = AllocationInstructionInterface;
+declare const index_d$8_AllocationInstructionResult: typeof AllocationInstructionResult;
+import index_d$8_AllocationInstructionResult_Output = AllocationInstructionResult_Output;
+declare const index_d$8_AllocationInstructionView: typeof AllocationInstructionView;
+declare const index_d$8_AllocationInstruction_Update: typeof AllocationInstruction_Update;
+declare const index_d$8_AllocationInstruction_Withdraw: typeof AllocationInstruction_Withdraw;
+declare namespace index_d$8 {
+  export { index_d$8_AllocationFactory as AllocationFactory, index_d$8_AllocationFactoryView as AllocationFactoryView, index_d$8_AllocationFactory_Allocate as AllocationFactory_Allocate, index_d$8_AllocationFactory_PublicFetch as AllocationFactory_PublicFetch, index_d$8_AllocationInstruction as AllocationInstruction, index_d$8_AllocationInstructionResult as AllocationInstructionResult, index_d$8_AllocationInstructionResult_Output as AllocationInstructionResult_Output, index_d$8_AllocationInstructionView as AllocationInstructionView, index_d$8_AllocationInstruction_Update as AllocationInstruction_Update, index_d$8_AllocationInstruction_Withdraw as AllocationInstruction_Withdraw };
+  export type { index_d$8_AllocationFactoryInterface as AllocationFactoryInterface, index_d$8_AllocationInstructionInterface as AllocationInstructionInterface };
+}
+
+// Generated from Splice/Api/Token/AllocationRequestV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface AllocationRequestInterface {
+    Archive: damlTypes.Choice<
+        AllocationRequest,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationRequest, undefined>
+        >
+    AllocationRequest_Reject: damlTypes.Choice<
+        AllocationRequest,
+        AllocationRequest_Reject,
+        ChoiceExecutionMetadata,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationRequest, undefined>
+        >
+    AllocationRequest_Withdraw: damlTypes.Choice<
+        AllocationRequest,
+        AllocationRequest_Withdraw,
+        ChoiceExecutionMetadata,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<AllocationRequest, undefined>
+        >
+}
+
+declare type AllocationRequest =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationRequestV1:AllocationRequest'> &
+        AllocationRequestView
+declare const AllocationRequest: damlTypes.InterfaceCompanion<
+    AllocationRequest,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.AllocationRequestV1:AllocationRequest'
+> &
+    damlTypes.FromTemplate<AllocationRequest, unknown> &
+    AllocationRequestInterface
+
+declare type AllocationRequestView = {
+    settlement: SettlementInfo
+    transferLegs: { [key: string]: TransferLeg }
+    meta: Metadata
+}
+
+declare const AllocationRequestView: damlTypes.Serializable<AllocationRequestView> & {}
+
+declare type AllocationRequest_Withdraw = {
+    extraArgs: ExtraArgs
+}
+
+declare const AllocationRequest_Withdraw: damlTypes.Serializable<AllocationRequest_Withdraw> & {}
+
+declare type AllocationRequest_Reject = {
+    actor: damlTypes.Party
+    extraArgs: ExtraArgs
+}
+
+declare const AllocationRequest_Reject: damlTypes.Serializable<AllocationRequest_Reject> & {}
+
+declare const index_d$7_AllocationRequest: typeof AllocationRequest;
+type index_d$7_AllocationRequestInterface = AllocationRequestInterface;
+declare const index_d$7_AllocationRequestView: typeof AllocationRequestView;
+declare const index_d$7_AllocationRequest_Reject: typeof AllocationRequest_Reject;
+declare const index_d$7_AllocationRequest_Withdraw: typeof AllocationRequest_Withdraw;
+declare namespace index_d$7 {
+  export { index_d$7_AllocationRequest as AllocationRequest, index_d$7_AllocationRequestView as AllocationRequestView, index_d$7_AllocationRequest_Reject as AllocationRequest_Reject, index_d$7_AllocationRequest_Withdraw as AllocationRequest_Withdraw };
+  export type { index_d$7_AllocationRequestInterface as AllocationRequestInterface };
+}
+
+declare const index_d$6_Allocation: typeof Allocation;
+type index_d$6_AllocationInterface = AllocationInterface;
+declare const index_d$6_AllocationSpecification: typeof AllocationSpecification;
+declare const index_d$6_AllocationView: typeof AllocationView;
+declare const index_d$6_Allocation_Cancel: typeof Allocation_Cancel;
+declare const index_d$6_Allocation_CancelResult: typeof Allocation_CancelResult;
+declare const index_d$6_Allocation_ExecuteTransfer: typeof Allocation_ExecuteTransfer;
+declare const index_d$6_Allocation_ExecuteTransferResult: typeof Allocation_ExecuteTransferResult;
+declare const index_d$6_Allocation_Withdraw: typeof Allocation_Withdraw;
+declare const index_d$6_Allocation_WithdrawResult: typeof Allocation_WithdrawResult;
+declare const index_d$6_Reference: typeof Reference;
+declare const index_d$6_SettlementInfo: typeof SettlementInfo;
+declare const index_d$6_TransferLeg: typeof TransferLeg;
+declare namespace index_d$6 {
+  export { index_d$6_Allocation as Allocation, index_d$6_AllocationSpecification as AllocationSpecification, index_d$6_AllocationView as AllocationView, index_d$6_Allocation_Cancel as Allocation_Cancel, index_d$6_Allocation_CancelResult as Allocation_CancelResult, index_d$6_Allocation_ExecuteTransfer as Allocation_ExecuteTransfer, index_d$6_Allocation_ExecuteTransferResult as Allocation_ExecuteTransferResult, index_d$6_Allocation_Withdraw as Allocation_Withdraw, index_d$6_Allocation_WithdrawResult as Allocation_WithdrawResult, index_d$6_Reference as Reference, index_d$6_SettlementInfo as SettlementInfo, index_d$6_TransferLeg as TransferLeg };
+  export type { index_d$6_AllocationInterface as AllocationInterface };
+}
+
+declare const index_d$5_Holding: typeof Holding;
+type index_d$5_HoldingInterface = HoldingInterface;
+declare const index_d$5_HoldingView: typeof HoldingView;
+declare const index_d$5_InstrumentId: typeof InstrumentId;
+declare const index_d$5_Lock: typeof Lock;
+declare namespace index_d$5 {
+  export { index_d$5_Holding as Holding, index_d$5_HoldingView as HoldingView, index_d$5_InstrumentId as InstrumentId, index_d$5_Lock as Lock };
+  export type { index_d$5_HoldingInterface as HoldingInterface };
+}
+
+declare const index_d$4_AnyContract: typeof AnyContract;
+type index_d$4_AnyContractInterface = AnyContractInterface;
+declare const index_d$4_AnyContractView: typeof AnyContractView;
+declare const index_d$4_AnyValue: typeof AnyValue;
+declare const index_d$4_ChoiceContext: typeof ChoiceContext;
+declare const index_d$4_ChoiceExecutionMetadata: typeof ChoiceExecutionMetadata;
+declare const index_d$4_ExtraArgs: typeof ExtraArgs;
+declare const index_d$4_Metadata: typeof Metadata;
+declare namespace index_d$4 {
+  export { index_d$4_AnyContract as AnyContract, index_d$4_AnyContractView as AnyContractView, index_d$4_AnyValue as AnyValue, index_d$4_ChoiceContext as ChoiceContext, index_d$4_ChoiceExecutionMetadata as ChoiceExecutionMetadata, index_d$4_ExtraArgs as ExtraArgs, index_d$4_Metadata as Metadata };
+  export type { index_d$4_AnyContractInterface as AnyContractInterface };
+}
+
+// Generated from Splice/Api/Token/TransferInstructionV1.daml
+/* eslint-disable @typescript-eslint/camelcase */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+declare interface TransferFactoryInterface {
+    Archive: damlTypes.Choice<
+        TransferFactory,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferFactory, undefined>
+        >
+    TransferFactory_Transfer: damlTypes.Choice<
+        TransferFactory,
+        TransferFactory_Transfer,
+        TransferInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferFactory, undefined>
+        >
+    TransferFactory_PublicFetch: damlTypes.Choice<
+        TransferFactory,
+        TransferFactory_PublicFetch,
+        TransferFactoryView,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferFactory, undefined>
+        >
+}
+
+declare type TransferFactory =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.TransferInstructionV1:TransferFactory'> &
+        TransferFactoryView
+declare const TransferFactory: damlTypes.InterfaceCompanion<
+    TransferFactory,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.TransferInstructionV1:TransferFactory'
+> &
+    damlTypes.FromTemplate<TransferFactory, unknown> &
+    TransferFactoryInterface
+declare interface TransferInstructionInterface {
+    Archive: damlTypes.Choice<
+        TransferInstruction,
+        Archive,
+        {},
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferInstruction, undefined>
+        >
+    TransferInstruction_Accept: damlTypes.Choice<
+        TransferInstruction,
+        TransferInstruction_Accept,
+        TransferInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferInstruction, undefined>
+        >
+    TransferInstruction_Reject: damlTypes.Choice<
+        TransferInstruction,
+        TransferInstruction_Reject,
+        TransferInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferInstruction, undefined>
+        >
+    TransferInstruction_Withdraw: damlTypes.Choice<
+        TransferInstruction,
+        TransferInstruction_Withdraw,
+        TransferInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferInstruction, undefined>
+        >
+    TransferInstruction_Update: damlTypes.Choice<
+        TransferInstruction,
+        TransferInstruction_Update,
+        TransferInstructionResult,
+        undefined
+    > &
+        damlTypes.ChoiceFrom<
+            damlTypes.InterfaceCompanion<TransferInstruction, undefined>
+        >
+}
+
+declare type TransferInstruction =
+    damlTypes.Interface<'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.TransferInstructionV1:TransferInstruction'> &
+        TransferInstructionView
+declare const TransferInstruction: damlTypes.InterfaceCompanion<
+    TransferInstruction,
+    undefined,
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c:Splice.Api.Token.TransferInstructionV1:TransferInstruction'
+> &
+    damlTypes.FromTemplate<TransferInstruction, unknown> &
+    TransferInstructionInterface
+
+declare type TransferFactoryView = {
+    admin: damlTypes.Party
+    meta: Metadata
+}
+
+declare const TransferFactoryView: damlTypes.Serializable<TransferFactoryView> & {}
+
+declare type TransferFactory_PublicFetch = {
+    expectedAdmin: damlTypes.Party
+    actor: damlTypes.Party
+}
+
+declare const TransferFactory_PublicFetch: damlTypes.Serializable<TransferFactory_PublicFetch> & {}
+
+declare type TransferFactory_Transfer = {
+    expectedAdmin: damlTypes.Party
+    transfer: Transfer
+    extraArgs: ExtraArgs
+}
+
+declare const TransferFactory_Transfer: damlTypes.Serializable<TransferFactory_Transfer> & {}
+
+declare type TransferInstruction_Update = {
+    extraActors: damlTypes.Party[]
+    extraArgs: ExtraArgs
+}
+
+declare const TransferInstruction_Update: damlTypes.Serializable<TransferInstruction_Update> & {}
+
+declare type TransferInstruction_Withdraw = {
+    extraArgs: ExtraArgs
+}
+
+declare const TransferInstruction_Withdraw: damlTypes.Serializable<TransferInstruction_Withdraw> & {}
+
+declare type TransferInstruction_Reject = {
+    extraArgs: ExtraArgs
+}
+
+declare const TransferInstruction_Reject: damlTypes.Serializable<TransferInstruction_Reject> & {}
+
+declare type TransferInstruction_Accept = {
+    extraArgs: ExtraArgs
+}
+
+declare const TransferInstruction_Accept: damlTypes.Serializable<TransferInstruction_Accept> & {}
+
+declare type TransferInstructionView = {
+    originalInstructionCid: damlTypes.Optional<
+        damlTypes.ContractId<TransferInstruction>
+    >
+    transfer: Transfer
+    status: TransferInstructionStatus
+    meta: Metadata
+}
+
+declare const TransferInstructionView: damlTypes.Serializable<TransferInstructionView> & {}
+
+declare type TransferInstructionStatus =
+    | { tag: 'TransferPendingReceiverAcceptance'; value: {} }
+    | {
+          tag: 'TransferPendingInternalWorkflow'
+          value: TransferInstructionStatus.TransferPendingInternalWorkflow
+      }
+
+declare const TransferInstructionStatus: damlTypes.Serializable<TransferInstructionStatus> & {
+    TransferPendingInternalWorkflow: damlTypes.Serializable<TransferInstructionStatus.TransferPendingInternalWorkflow>
+}
+
+declare namespace TransferInstructionStatus {
+    type TransferPendingInternalWorkflow = {
+        pendingActions: damlTypes.Map<damlTypes.Party, string>
+    }
+} //namespace TransferInstructionStatus
+
+declare type TransferInstructionResult_Output =
+    | {
+          tag: 'TransferInstructionResult_Pending'
+          value: TransferInstructionResult_Output.TransferInstructionResult_Pending
+      }
+    | {
+          tag: 'TransferInstructionResult_Completed'
+          value: TransferInstructionResult_Output.TransferInstructionResult_Completed
+      }
+    | { tag: 'TransferInstructionResult_Failed'; value: {} }
+
+declare const TransferInstructionResult_Output: damlTypes.Serializable<TransferInstructionResult_Output> & {
+    TransferInstructionResult_Pending: damlTypes.Serializable<TransferInstructionResult_Output.TransferInstructionResult_Pending>
+    TransferInstructionResult_Completed: damlTypes.Serializable<TransferInstructionResult_Output.TransferInstructionResult_Completed>
+}
+
+declare namespace TransferInstructionResult_Output {
+    type TransferInstructionResult_Pending = {
+        transferInstructionCid: damlTypes.ContractId<TransferInstruction>
+    }
+} //namespace TransferInstructionResult_Output
+
+declare namespace TransferInstructionResult_Output {
+    type TransferInstructionResult_Completed = {
+        receiverHoldingCids: damlTypes.ContractId<Holding>[]
+    }
+} //namespace TransferInstructionResult_Output
+
+declare type TransferInstructionResult = {
+    output: TransferInstructionResult_Output
+    senderChangeCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const TransferInstructionResult: damlTypes.Serializable<TransferInstructionResult> & {}
+
+declare type Transfer = {
+    sender: damlTypes.Party
+    receiver: damlTypes.Party
+    amount: damlTypes.Numeric
+    instrumentId: InstrumentId
+    requestedAt: damlTypes.Time
+    executeBefore: damlTypes.Time
+    inputHoldingCids: damlTypes.ContractId<Holding>[]
+    meta: Metadata
+}
+
+declare const Transfer: damlTypes.Serializable<Transfer> & {}
+
+declare const index_d$3_Transfer: typeof Transfer;
+declare const index_d$3_TransferFactory: typeof TransferFactory;
+type index_d$3_TransferFactoryInterface = TransferFactoryInterface;
+declare const index_d$3_TransferFactoryView: typeof TransferFactoryView;
+declare const index_d$3_TransferFactory_PublicFetch: typeof TransferFactory_PublicFetch;
+declare const index_d$3_TransferFactory_Transfer: typeof TransferFactory_Transfer;
+declare const index_d$3_TransferInstruction: typeof TransferInstruction;
+type index_d$3_TransferInstructionInterface = TransferInstructionInterface;
+declare const index_d$3_TransferInstructionResult: typeof TransferInstructionResult;
+import index_d$3_TransferInstructionResult_Output = TransferInstructionResult_Output;
+import index_d$3_TransferInstructionStatus = TransferInstructionStatus;
+declare const index_d$3_TransferInstructionView: typeof TransferInstructionView;
+declare const index_d$3_TransferInstruction_Accept: typeof TransferInstruction_Accept;
+declare const index_d$3_TransferInstruction_Reject: typeof TransferInstruction_Reject;
+declare const index_d$3_TransferInstruction_Update: typeof TransferInstruction_Update;
+declare const index_d$3_TransferInstruction_Withdraw: typeof TransferInstruction_Withdraw;
+declare namespace index_d$3 {
+  export { index_d$3_Transfer as Transfer, index_d$3_TransferFactory as TransferFactory, index_d$3_TransferFactoryView as TransferFactoryView, index_d$3_TransferFactory_PublicFetch as TransferFactory_PublicFetch, index_d$3_TransferFactory_Transfer as TransferFactory_Transfer, index_d$3_TransferInstruction as TransferInstruction, index_d$3_TransferInstructionResult as TransferInstructionResult, index_d$3_TransferInstructionResult_Output as TransferInstructionResult_Output, index_d$3_TransferInstructionStatus as TransferInstructionStatus, index_d$3_TransferInstructionView as TransferInstructionView, index_d$3_TransferInstruction_Accept as TransferInstruction_Accept, index_d$3_TransferInstruction_Reject as TransferInstruction_Reject, index_d$3_TransferInstruction_Update as TransferInstruction_Update, index_d$3_TransferInstruction_Withdraw as TransferInstruction_Withdraw };
+  export type { index_d$3_TransferFactoryInterface as TransferFactoryInterface, index_d$3_TransferInstructionInterface as TransferInstructionInterface };
+}
+
+declare namespace index_d$2 {
+  export {
+    index_d$8 as AllocationInstructionV1,
+    index_d$7 as AllocationRequestV1,
+    index_d$6 as AllocationV1,
+    index_d$5 as HoldingV1,
+    index_d$4 as MetadataV1,
+    index_d$3 as TransferInstructionV1,
+  };
+}
+
+declare namespace index_d$1 {
+  export {
+    index_d$2 as Token,
+  };
+}
+
+declare namespace index_d {
+  export {
+    index_d$1 as Api,
+  };
+}
+
+declare const packageId =
+    'a132be8b23c8515da6c828dd97519a73d9c8b1aa6f9cddd3c7acc206e4b41f8c'
+
+declare const TransferInstructionV1: typeof index_d$3;
+declare const AllocationInstructionV1: typeof index_d$8;
+declare const AllocationRequestV1: typeof index_d$7;
+declare const AllocationV1: typeof index_d$6;
+declare const HoldingV1: typeof index_d$5;
+declare const MetadataV1: typeof index_d$4;
+
+type Beneficiaries = {
+    beneficiary: PartyId;
+    weight: number;
+};
+
+export { ALLOCATION_FACTORY_INTERFACE_ID, ALLOCATION_INSTRUCTION_INTERFACE_ID, ALLOCATION_INTERFACE_ID, ALLOCATION_REQUEST_INTERFACE_ID, Allocation, AllocationFactory, AllocationFactoryView, AllocationFactory_Allocate, AllocationFactory_PublicFetch, AllocationInstruction, AllocationInstructionResult, AllocationInstructionResult_Output, AllocationInstructionV1, AllocationInstructionView, AllocationInstruction_Update, AllocationInstruction_Withdraw, AllocationRequest, AllocationRequestV1, AllocationRequestView, AllocationRequest_Reject, AllocationRequest_Withdraw, AllocationSpecification, AllocationV1, AllocationView, Allocation_Cancel, Allocation_CancelResult, Allocation_ExecuteTransfer, Allocation_ExecuteTransferResult, Allocation_Withdraw, Allocation_WithdrawResult, AnyContract, AnyContractView, AnyValue, ChoiceContext, ChoiceExecutionMetadata, ExtraArgs, FEATURED_APP_DELEGATE_PROXY_INTERFACE_ID, HOLDING_INTERFACE_ID, Holding, HoldingV1, HoldingView, InstrumentId, Lock, METADATA_INTERFACE_ID, Metadata, MetadataV1, Reference, SettlementInfo, index_d as Splice, TRANSFER_FACTORY_INTERFACE_ID, TRANSFER_INSTRUCTION_INTERFACE_ID, TokenStandardClient, Transfer, TransferFactory, TransferFactoryView, TransferFactory_PublicFetch, TransferFactory_Transfer, TransferInstruction, TransferInstructionResult, TransferInstructionResult_Output, TransferInstructionStatus, TransferInstructionV1, TransferInstructionView, TransferInstruction_Accept, TransferInstruction_Reject, TransferInstruction_Update, TransferInstruction_Withdraw, TransferLeg, packageId };
+export type { AllocationFactoryInterface, AllocationInstructionInterface, AllocationInterface, AllocationRequestInterface, AnyContractInterface, Beneficiaries, GetResponse, HoldingInterface, PostRequest, PostResponse, TransferFactoryInterface, TransferInstructionInterface, components$2 as allocationInstructionRegistryTypes, components$3 as allocationRegistryTypes, components$1 as metadataRegistryTypes, components as transferInstructionRegistryTypes };