@oumla/sdk 1.2.3 → 1.3.0

package/dist/index.d.ts

@@ -1,88 +1,108 @@
-declare const GetDeployedContractsRequestNetwork: {
-    readonly Btc: "BTC";
+declare const GetNativeBalanceRequestNetwork: {
     readonly TBtc: "tBTC";
-    readonly Eth: "ETH";
     readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
 };
-type GetDeployedContractsRequestNetwork = (typeof GetDeployedContractsRequestNetwork)[keyof typeof GetDeployedContractsRequestNetwork];
+type GetNativeBalanceRequestNetwork = (typeof GetNativeBalanceRequestNetwork)[keyof typeof GetNativeBalanceRequestNetwork];
 
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1,
+ *         address: "address",
+ *         walletId: "walletId",
  *         contractAddress: "contractAddress",
- *         network: "BTC",
- *         contractTemplateId: "contractTemplateId"
+ *         tokenizationId: "tokenizationId",
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface GetDeployedContractsRequest {
+interface GetAssetsRequest {
+    /** Blockchain address */
+    address?: string;
+    /** Wallet identifier */
+    walletId?: string;
+    /** Smart contract address */
+    contractAddress?: string;
+    /** Tokenization identifier */
+    tokenizationId?: string;
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
     take?: number;
-    /** Filter by contract address */
-    contractAddress?: string;
-    /** Filter by blockchain network */
-    network?: GetDeployedContractsRequestNetwork;
-    /** Filter by contract template ID */
-    contractTemplateId?: string;
-}
-
-/**
- * @example
- *     {
- *         network: "network",
- *         contractAddress: "contractAddress"
- *     }
- */
-interface FetchContractAbiRequest {
-    /** Blockchain network */
-    network: string;
-    /** Contract address */
-    contractAddress: string;
 }
 
 /**
  * @example
  *     {
- *         network: "network",
- *         contractAddress: "contractAddress",
- *         name: "name",
- *         abi: [{
- *                 "key": "value"
- *             }]
+ *         network: "tBTC",
+ *         address: "address",
+ *         walletId: "walletId",
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface AddContractAbiRequest {
+interface GetNativeBalanceRequest {
     /** Blockchain network */
-    network: string;
-    /** Contract address */
-    contractAddress: string;
-    /** Contract name */
-    name: string;
-    /** Contract ABI */
-    abi: Record<string, unknown>[];
+    network: GetNativeBalanceRequestNetwork;
+    /** Blockchain address */
+    address?: string;
+    /** Wallet identifier */
+    walletId?: string;
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
-type index$b_AddContractAbiRequest = AddContractAbiRequest;
-type index$b_FetchContractAbiRequest = FetchContractAbiRequest;
-type index$b_GetDeployedContractsRequest = GetDeployedContractsRequest;
-type index$b_GetDeployedContractsRequestNetwork = GetDeployedContractsRequestNetwork;
+type index$b_GetAssetsRequest = GetAssetsRequest;
+type index$b_GetNativeBalanceRequest = GetNativeBalanceRequest;
+type index$b_GetNativeBalanceRequestNetwork = GetNativeBalanceRequestNetwork;
 declare namespace index$b {
   export {
-    index$b_AddContractAbiRequest as AddContractAbiRequest,
-    index$b_FetchContractAbiRequest as FetchContractAbiRequest,
-    index$b_GetDeployedContractsRequest as GetDeployedContractsRequest,
-    index$b_GetDeployedContractsRequestNetwork as GetDeployedContractsRequestNetwork,
+    index$b_GetAssetsRequest as GetAssetsRequest,
+    index$b_GetNativeBalanceRequest as GetNativeBalanceRequest,
+    index$b_GetNativeBalanceRequestNetwork as GetNativeBalanceRequestNetwork,
   };
 }
 
-declare const GetCollectionTokensRequestType: {
-    readonly Mint: "MINT";
-    readonly Burn: "BURN";
-};
-type GetCollectionTokensRequestType = (typeof GetCollectionTokensRequestType)[keyof typeof GetCollectionTokensRequestType];
+interface LinkContractResponse {
+    link?: TokenData;
+}
+
+interface GetLinkedTokenResponse {
+    token?: TokenData;
+}
+
+interface UnlinkTokenResponse {
+    result?: UnlinkTokenResponse.Result;
+}
+declare namespace UnlinkTokenResponse {
+    interface Result {
+        success?: boolean;
+    }
+}
+
+interface MintTokenResponse {
+    mint?: MintTokenResponse.Mint;
+}
+declare namespace MintTokenResponse {
+    interface Mint {
+        workflowId?: string;
+        status?: string;
+    }
+}
+
+interface BurnTokenResponse {
+    burn?: BurnTokenResponse.Burn;
+}
+declare namespace BurnTokenResponse {
+    interface Burn {
+        workflowId?: string;
+        status?: string;
+    }
+}
 
 /**
  * @example
@@ -101,55 +121,35 @@ interface GetTokensRequest {
 /**
  * @example
  *     {
+ *         network: "tBTC",
  *         addressId: "addressId",
  *         clientShare: "clientShare",
- *         deploymentId: "deploymentId",
  *         createParams: {
- *             initializeParams: [{
- *                     name: "name",
- *                     type: "type",
- *                     value: "value"
- *                 }]
- *         }
+ *             "key": "value"
+ *         },
+ *         deploymentId: "deploymentId"
  *     }
  */
 interface IssueNewTokenRequest {
-    /** Blockchain network */
-    network?: string;
-    /** Address ID for token creation */
+    network: IssueNewTokenRequest.Network;
     addressId: string;
-    /** Client share for signing */
     clientShare: string;
-    /** Deployed contract ID */
-    deploymentId: string;
-    createParams: IssueNewTokenRequest.CreateParams;
-    /** Token display name */
+    createParams: Record<string, unknown>;
     displayName?: string;
-    /** Use gasless transaction */
+    deploymentId: string;
     useGasless?: boolean;
-    /** Transaction fee */
     fee?: string;
-    /** Fee level */
     feeLevel?: string;
 }
 declare namespace IssueNewTokenRequest {
-    interface CreateParams {
-        /** Initialize parameters */
-        initializeParams: CreateParams.InitializeParams.Item[];
-    }
-    namespace CreateParams {
-        type InitializeParams = InitializeParams.Item[];
-        namespace InitializeParams {
-            interface Item {
-                /** Parameter name */
-                name: string;
-                /** Parameter type */
-                type: string;
-                /** Parameter value */
-                value: string;
-            }
-        }
-    }
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
 }
 
 /**
@@ -159,16 +159,11 @@ declare namespace IssueNewTokenRequest {
  *     }
  */
 interface LinkContractRequest {
-    /** Contract type */
-    type?: string;
-    /** Reference ID */
-    refId?: string;
-    /** Display name */
-    displayName?: string;
-    /** Blockchain network */
-    network?: string;
-    /** Contract address */
     contractAddress: string;
+    network?: string;
+    displayName?: string;
+    refId?: string;
+    type?: string;
 }
 
 /**
@@ -188,117 +183,44 @@ interface GetCollectionsRequest {
 /**
  * @example
  *     {
- *         type: "NON_FUNGIBLE_TOKEN",
+ *         network: "network",
  *         addressId: "addressId",
  *         clientShare: "clientShare",
  *         createParams: {
- *             initializeParams: [{
- *                     name: "name",
- *                     type: "type",
- *                     value: "value"
- *                 }]
- *         }
+ *             "key": "value"
+ *         },
+ *         deploymentId: "deploymentId"
  *     }
  */
 interface CreateCollectionRequest {
-    /** Blockchain network */
-    network?: string;
-    /** Collection type */
-    type: CreateCollectionRequest.Type;
-    /** Address ID for collection creation */
+    network: string;
     addressId: string;
-    /** Client share for signing */
     clientShare: string;
-    createParams: CreateCollectionRequest.CreateParams;
-    /** Collection description */
-    description?: string;
-    /** Collection display name */
+    createParams: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
     displayName?: string;
-    /** Use gasless transaction */
+    deploymentId: string;
     useGasless?: boolean;
-    /** Transaction fee */
     fee?: string;
-    /** Fee level */
     feeLevel?: string;
 }
-declare namespace CreateCollectionRequest {
-    /** Collection type */
-    const Type: {
-        readonly NonFungibleToken: "NON_FUNGIBLE_TOKEN";
-        readonly SemiFungibleToken: "SEMI_FUNGIBLE_TOKEN";
-    };
-    type Type = (typeof Type)[keyof typeof Type];
-    interface CreateParams {
-        /** Initialize parameters */
-        initializeParams: CreateParams.InitializeParams.Item[];
-    }
-    namespace CreateParams {
-        type InitializeParams = InitializeParams.Item[];
-        namespace InitializeParams {
-            interface Item {
-                /** Parameter name */
-                name: string;
-                /** Parameter type */
-                type: string;
-                /** Parameter value */
-                value: string;
-            }
-        }
-    }
-}
 
 /**
  * @example
  *     {
  *         addressId: "addressId",
  *         clientShare: "clientShare",
- *         to: "to",
- *         tokenId: "tokenId"
+ *         to: "to"
  *     }
  */
 interface MintTokenRequest {
-    /** Address ID for minting */
     addressId: string;
-    /** Client share for signing */
     clientShare: string;
-    /** Recipient address */
     to: string;
-    /** Token ID */
-    tokenId: string;
-    /** Token amount */
-    amount?: string;
-    /** Token metadata URI */
-    metadataURI?: string;
-    metadata?: MintTokenRequest.Metadata;
-}
-declare namespace MintTokenRequest {
-    interface Metadata {
-        /** Token name */
-        name: string;
-        /** Token description */
-        description: string;
-        /** Token image URL */
-        image?: string;
-        /** Token animation URL */
-        animation_url?: string;
-        /** External URL */
-        external_url?: string;
-        /** Token attributes */
-        attributes?: Metadata.Attributes.Item[];
-    }
-    namespace Metadata {
-        type Attributes = Attributes.Item[];
-        namespace Attributes {
-            interface Item {
-                /** Trait type */
-                trait_type: string;
-                /** Trait value */
-                value: string;
-                /** Display type */
-                display_type?: string;
-            }
-        }
-    }
+    metadata?: Record<string, unknown>;
+    useGasless?: boolean;
+    fee?: string;
+    feeLevel?: string;
 }
 
 /**
@@ -310,32 +232,28 @@ declare namespace MintTokenRequest {
  *     }
  */
 interface BurnTokenRequest {
-    /** Address ID for burning */
     addressId: string;
-    /** Client share for signing */
     clientShare: string;
-    /** Token ID */
     tokenId: string;
-    /** Address to burn from */
-    from?: string;
-    /** Token amount to burn */
-    amount?: string;
+    useGasless?: boolean;
+    fee?: string;
+    feeLevel?: string;
 }
 
 /**
  * @example
  *     {
  *         id: "id",
- *         type: "MINT",
+ *         type: "type",
  *         skip: 1,
  *         take: 1
  *     }
  */
 interface GetCollectionTokensRequest {
-    /** Collection ID to filter by */
+    /** Collection ID */
     id?: string;
-    /** Record type to filter by */
-    type?: GetCollectionTokensRequestType;
+    /** Token type */
+    type?: string;
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
@@ -343,28 +261,46 @@ interface GetCollectionTokensRequest {
 }
 
 type index$a_BurnTokenRequest = BurnTokenRequest;
-declare const index$a_CreateCollectionRequest: typeof CreateCollectionRequest;
+declare const index$a_BurnTokenResponse: typeof BurnTokenResponse;
+type index$a_CreateCollectionRequest = CreateCollectionRequest;
 type index$a_GetCollectionTokensRequest = GetCollectionTokensRequest;
-type index$a_GetCollectionTokensRequestType = GetCollectionTokensRequestType;
 type index$a_GetCollectionsRequest = GetCollectionsRequest;
+type index$a_GetLinkedTokenResponse = GetLinkedTokenResponse;
 type index$a_GetTokensRequest = GetTokensRequest;
 declare const index$a_IssueNewTokenRequest: typeof IssueNewTokenRequest;
 type index$a_LinkContractRequest = LinkContractRequest;
-declare const index$a_MintTokenRequest: typeof MintTokenRequest;
+type index$a_LinkContractResponse = LinkContractResponse;
+type index$a_MintTokenRequest = MintTokenRequest;
+declare const index$a_MintTokenResponse: typeof MintTokenResponse;
+declare const index$a_UnlinkTokenResponse: typeof UnlinkTokenResponse;
 declare namespace index$a {
   export {
     index$a_BurnTokenRequest as BurnTokenRequest,
+    index$a_BurnTokenResponse as BurnTokenResponse,
     index$a_CreateCollectionRequest as CreateCollectionRequest,
     index$a_GetCollectionTokensRequest as GetCollectionTokensRequest,
-    index$a_GetCollectionTokensRequestType as GetCollectionTokensRequestType,
     index$a_GetCollectionsRequest as GetCollectionsRequest,
+    index$a_GetLinkedTokenResponse as GetLinkedTokenResponse,
     index$a_GetTokensRequest as GetTokensRequest,
     index$a_IssueNewTokenRequest as IssueNewTokenRequest,
     index$a_LinkContractRequest as LinkContractRequest,
+    index$a_LinkContractResponse as LinkContractResponse,
     index$a_MintTokenRequest as MintTokenRequest,
+    index$a_MintTokenResponse as MintTokenResponse,
+    index$a_UnlinkTokenResponse as UnlinkTokenResponse,
   };
 }
 
+interface DeployContractResponse {
+    contractFunction?: DeployContractResponse.ContractFunction;
+}
+declare namespace DeployContractResponse {
+    interface ContractFunction {
+        workflowId?: string;
+        status?: string;
+    }
+}
+
 /**
  * @example
  *     {
@@ -372,7 +308,7 @@ declare namespace index$a {
  *         take: 1
  *     }
  */
-interface GetProfilesRequest {
+interface GetContractsRequest {
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
@@ -382,43 +318,89 @@ interface GetProfilesRequest {
 /**
  * @example
  *     {
- *         reference: "reference",
- *         type: "User"
+ *         name: "name",
+ *         description: "description",
+ *         bytecode: "bytecode",
+ *         abi: [{
+ *                 "key": "value"
+ *             }]
  *     }
  */
-interface CreateProfileRequest {
-    /** Profile reference identifier */
-    reference: string;
-    /** Profile type */
-    type: CreateProfileRequest.Type;
+interface CreateContractRequest {
+    name: string;
+    description: string;
+    bytecode: string;
+    abi: Record<string, unknown>[];
+    longDescription?: string;
+    sourceCode?: string;
+    type?: string;
+    docs?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
 }
-declare namespace CreateProfileRequest {
-    /** Profile type */
-    const Type: {
-        readonly User: "User";
-        readonly Department: "Department";
-        readonly Merchant: "Merchant";
-    };
-    type Type = (typeof Type)[keyof typeof Type];
+
+/**
+ * @example
+ *     {
+ *         network: "network",
+ *         addressId: "addressId",
+ *         clientShare: "clientShare"
+ *     }
+ */
+interface DeployContractRequest {
+    network: string;
+    addressId: string;
+    clientShare: string;
+    constructorParameters?: Record<string, unknown>[];
 }
 
-declare const index$9_CreateProfileRequest: typeof CreateProfileRequest;
-type index$9_GetProfilesRequest = GetProfilesRequest;
+type index$9_CreateContractRequest = CreateContractRequest;
+type index$9_DeployContractRequest = DeployContractRequest;
+declare const index$9_DeployContractResponse: typeof DeployContractResponse;
+type index$9_GetContractsRequest = GetContractsRequest;
 declare namespace index$9 {
   export {
-    index$9_CreateProfileRequest as CreateProfileRequest,
-    index$9_GetProfilesRequest as GetProfilesRequest,
+    index$9_CreateContractRequest as CreateContractRequest,
+    index$9_DeployContractRequest as DeployContractRequest,
+    index$9_DeployContractResponse as DeployContractResponse,
+    index$9_GetContractsRequest as GetContractsRequest,
   };
 }
 
+declare const GetDeployedContractsRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type GetDeployedContractsRequestNetwork = (typeof GetDeployedContractsRequestNetwork)[keyof typeof GetDeployedContractsRequestNetwork];
+
+declare const GetDeployedContractByAddressRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type GetDeployedContractByAddressRequestNetwork = (typeof GetDeployedContractByAddressRequestNetwork)[keyof typeof GetDeployedContractByAddressRequestNetwork];
+
 /**
  * @example
  *     {
+ *         contractAddress: "contractAddress",
+ *         network: "tBTC",
+ *         contractTemplateId: "contractTemplateId",
  *         skip: 1,
  *         take: 1
  *     }
  */
-interface GetOrganizationWalletsRequest {
+interface GetDeployedContractsRequest {
+    /** Contract address filter */
+    contractAddress?: string;
+    /** Network filter */
+    network?: GetDeployedContractsRequestNetwork;
+    /** Contract template ID filter */
+    contractTemplateId?: string;
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
@@ -428,86 +410,140 @@ interface GetOrganizationWalletsRequest {
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1
+ *         contractAddress: "contractAddress",
+ *         network: "network"
  *     }
  */
-interface GetProfileWalletsRequest {
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface FetchContractAbiRequest {
+    contractAddress: string;
+    network: string;
 }
 
 /**
  * @example
  *     {
- *         reference: "reference",
- *         network: "BTC"
+ *         contractAddress: "contractAddress",
+ *         network: "network",
+ *         name: "name",
+ *         abi: [{
+ *                 "key": "value"
+ *             }]
  *     }
  */
-interface CreateWalletRequest {
-    /** Profile reference */
-    reference: string;
-    /** Blockchain network */
-    network: CreateWalletRequest.Network;
-}
-declare namespace CreateWalletRequest {
-    /** Blockchain network */
-    const Network: {
-        readonly Btc: "BTC";
-        readonly TBtc: "tBTC";
-        readonly Eth: "ETH";
-        readonly TEth: "tETH";
-    };
-    type Network = (typeof Network)[keyof typeof Network];
+interface AddContractAbiRequest {
+    contractAddress: string;
+    network: string;
+    name: string;
+    abi: Record<string, unknown>[];
 }
 
-declare const index$8_CreateWalletRequest: typeof CreateWalletRequest;
-type index$8_GetOrganizationWalletsRequest = GetOrganizationWalletsRequest;
-type index$8_GetProfileWalletsRequest = GetProfileWalletsRequest;
+type index$8_AddContractAbiRequest = AddContractAbiRequest;
+type index$8_FetchContractAbiRequest = FetchContractAbiRequest;
+type index$8_GetDeployedContractByAddressRequestNetwork = GetDeployedContractByAddressRequestNetwork;
+type index$8_GetDeployedContractsRequest = GetDeployedContractsRequest;
+type index$8_GetDeployedContractsRequestNetwork = GetDeployedContractsRequestNetwork;
 declare namespace index$8 {
   export {
-    index$8_CreateWalletRequest as CreateWalletRequest,
-    index$8_GetOrganizationWalletsRequest as GetOrganizationWalletsRequest,
-    index$8_GetProfileWalletsRequest as GetProfileWalletsRequest,
+    index$8_AddContractAbiRequest as AddContractAbiRequest,
+    index$8_FetchContractAbiRequest as FetchContractAbiRequest,
+    index$8_GetDeployedContractByAddressRequestNetwork as GetDeployedContractByAddressRequestNetwork,
+    index$8_GetDeployedContractsRequest as GetDeployedContractsRequest,
+    index$8_GetDeployedContractsRequestNetwork as GetDeployedContractsRequestNetwork,
   };
 }
 
+declare const GetDeployedContractAbiRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type GetDeployedContractAbiRequestNetwork = (typeof GetDeployedContractAbiRequestNetwork)[keyof typeof GetDeployedContractAbiRequestNetwork];
+
+declare const ReadCallFunctionRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type ReadCallFunctionRequestNetwork = (typeof ReadCallFunctionRequestNetwork)[keyof typeof ReadCallFunctionRequestNetwork];
+
+declare const WriteCallFunctionRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type WriteCallFunctionRequestNetwork = (typeof WriteCallFunctionRequestNetwork)[keyof typeof WriteCallFunctionRequestNetwork];
+
+interface WriteCallFunctionResponse {
+    result?: WriteCallFunctionResponse.Result;
+}
+declare namespace WriteCallFunctionResponse {
+    interface Result {
+        workflowId?: string;
+        status?: string;
+    }
+}
+
+declare const GetTransactionReceiptRequestNetwork: {
+    readonly TBtc: "tBTC";
+    readonly TEth: "tETH";
+    readonly Avax: "AVAX";
+    readonly Fuji: "FUJI";
+    readonly Sandbox: "SANDBOX";
+};
+type GetTransactionReceiptRequestNetwork = (typeof GetTransactionReceiptRequestNetwork)[keyof typeof GetTransactionReceiptRequestNetwork];
+
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1
+ *         abiFunction: {
+ *             "key": "value"
+ *         }
  *     }
  */
-interface GetOrganizationAddressesRequest {
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface ReadCallFunctionRequest {
+    abiFunction: Record<string, unknown>;
 }
 
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1
+ *         addressId: "addressId",
+ *         clientShare: "clientShare",
+ *         abiFunction: {
+ *             "key": "value"
+ *         }
  *     }
  */
-interface GetProfileAddressesRequest {
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface WriteCallFunctionRequest {
+    addressId: string;
+    clientShare: string;
+    abiFunction: Record<string, unknown>;
+    amount?: string;
+    feeLevel?: string;
 }
 
-type index$7_GetOrganizationAddressesRequest = GetOrganizationAddressesRequest;
-type index$7_GetProfileAddressesRequest = GetProfileAddressesRequest;
+type index$7_GetDeployedContractAbiRequestNetwork = GetDeployedContractAbiRequestNetwork;
+type index$7_GetTransactionReceiptRequestNetwork = GetTransactionReceiptRequestNetwork;
+type index$7_ReadCallFunctionRequest = ReadCallFunctionRequest;
+type index$7_ReadCallFunctionRequestNetwork = ReadCallFunctionRequestNetwork;
+type index$7_WriteCallFunctionRequest = WriteCallFunctionRequest;
+type index$7_WriteCallFunctionRequestNetwork = WriteCallFunctionRequestNetwork;
+declare const index$7_WriteCallFunctionResponse: typeof WriteCallFunctionResponse;
 declare namespace index$7 {
   export {
-    index$7_GetOrganizationAddressesRequest as GetOrganizationAddressesRequest,
-    index$7_GetProfileAddressesRequest as GetProfileAddressesRequest,
+    index$7_GetDeployedContractAbiRequestNetwork as GetDeployedContractAbiRequestNetwork,
+    index$7_GetTransactionReceiptRequestNetwork as GetTransactionReceiptRequestNetwork,
+    index$7_ReadCallFunctionRequest as ReadCallFunctionRequest,
+    index$7_ReadCallFunctionRequestNetwork as ReadCallFunctionRequestNetwork,
+    index$7_WriteCallFunctionRequest as WriteCallFunctionRequest,
+    index$7_WriteCallFunctionRequestNetwork as WriteCallFunctionRequestNetwork,
+    index$7_WriteCallFunctionResponse as WriteCallFunctionResponse,
   };
 }
 
@@ -518,7 +554,7 @@ declare namespace index$7 {
  *         take: 1
  *     }
  */
-interface GetTransactionsByAddressRequest {
+interface GetProfilesRequest {
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
@@ -528,29 +564,58 @@ interface GetTransactionsByAddressRequest {
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1
+ *         reference: "user-123",
+ *         type: "User"
  *     }
  */
-interface GetTransactionsByWalletRequest {
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface CreateProfileRequest {
+    /** Profile reference identifier */
+    reference: string;
+    /** Profile type */
+    type: CreateProfileRequest.Type;
+}
+declare namespace CreateProfileRequest {
+    /** Profile type */
+    const Type: {
+        readonly User: "User";
+        readonly Department: "Department";
+        readonly Merchant: "Merchant";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}
+
+declare const index$6_CreateProfileRequest: typeof CreateProfileRequest;
+type index$6_GetProfilesRequest = GetProfilesRequest;
+declare namespace index$6 {
+  export {
+    index$6_CreateProfileRequest as CreateProfileRequest,
+    index$6_GetProfilesRequest as GetProfilesRequest,
+  };
 }
 
 /**
  * @example
  *     {
- *         skip: 1,
- *         take: 1
+ *         reference: "user-123",
+ *         network: "tBTC"
  *     }
  */
-interface GetOrganizationTransactionsRequest {
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface CreateWalletRequest {
+    /** Profile reference */
+    reference: string;
+    /** Blockchain network */
+    network: CreateWalletRequest.Network;
+}
+declare namespace CreateWalletRequest {
+    /** Blockchain network */
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
 }
 
 /**
@@ -560,63 +625,35 @@ interface GetOrganizationTransactionsRequest {
  *         take: 1
  *     }
  */
-interface GetProfileTransactionsRequest {
+interface GetWalletsByProfileRequest {
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
     take?: number;
 }
 
-type index$6_GetOrganizationTransactionsRequest = GetOrganizationTransactionsRequest;
-type index$6_GetProfileTransactionsRequest = GetProfileTransactionsRequest;
-type index$6_GetTransactionsByAddressRequest = GetTransactionsByAddressRequest;
-type index$6_GetTransactionsByWalletRequest = GetTransactionsByWalletRequest;
-declare namespace index$6 {
-  export {
-    index$6_GetOrganizationTransactionsRequest as GetOrganizationTransactionsRequest,
-    index$6_GetProfileTransactionsRequest as GetProfileTransactionsRequest,
-    index$6_GetTransactionsByAddressRequest as GetTransactionsByAddressRequest,
-    index$6_GetTransactionsByWalletRequest as GetTransactionsByWalletRequest,
-  };
-}
-
 /**
  * @example
  *     {
- *         to: "to",
- *         amount: "amount",
- *         from: ["from"],
- *         network: "BTC",
- *         clientShare: "clientShare"
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface CreateWithdrawalRequest {
-    /** Recipient address for withdrawal */
-    to: string;
-    /** Withdrawal amount */
-    amount: string;
-    /** Array of source addresses for withdrawal */
-    from: string[];
-    /** Blockchain network */
-    network: CreateWithdrawalRequest.Network;
-    /** Client share for signing */
-    clientShare: string;
-}
-declare namespace CreateWithdrawalRequest {
-    /** Blockchain network */
-    const Network: {
-        readonly Btc: "BTC";
-        readonly TBtc: "tBTC";
-        readonly Eth: "ETH";
-        readonly TEth: "tETH";
-    };
-    type Network = (typeof Network)[keyof typeof Network];
+interface GetWalletsForOrganizationRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
-declare const index$5_CreateWithdrawalRequest: typeof CreateWithdrawalRequest;
+declare const index$5_CreateWalletRequest: typeof CreateWalletRequest;
+type index$5_GetWalletsByProfileRequest = GetWalletsByProfileRequest;
+type index$5_GetWalletsForOrganizationRequest = GetWalletsForOrganizationRequest;
 declare namespace index$5 {
   export {
-    index$5_CreateWithdrawalRequest as CreateWithdrawalRequest,
+    index$5_CreateWalletRequest as CreateWalletRequest,
+    index$5_GetWalletsByProfileRequest as GetWalletsByProfileRequest,
+    index$5_GetWalletsForOrganizationRequest as GetWalletsForOrganizationRequest,
   };
 }
 
@@ -627,7 +664,7 @@ declare namespace index$5 {
  *         take: 1
  *     }
  */
-interface GetContractTemplatesRequest {
+interface GetAddressForOrganizationRequest {
     /** Number of records to skip */
     skip?: number;
     /** Number of records to take */
@@ -637,261 +674,92 @@ interface GetContractTemplatesRequest {
 /**
  * @example
  *     {
- *         name: "name",
- *         description: "description",
- *         abi: [{
- *                 "key": "value"
- *             }],
- *         bytecode: "bytecode"
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface CreateContractTemplateRequest {
-    /** Contract template name */
-    name: string;
-    /** Contract template description */
-    description: string;
-    /** Contract ABI */
-    abi: Record<string, unknown>[];
-    /** Contract bytecode */
-    bytecode: string;
-    /** Long description of the contract */
-    longDescription?: string;
-    /** Contract source code */
-    sourceCode?: string;
-    /** Contract type */
-    type?: string;
-    /** Contract documentation */
-    docs?: CreateContractTemplateRequest.Docs;
-    /** Contract attributes */
-    attributes?: CreateContractTemplateRequest.Attributes;
+interface GetAddressForProfileRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
-declare namespace CreateContractTemplateRequest {
-    /**
-     * Contract documentation
-     */
-    interface Docs {
-        details?: string;
-        events?: string;
-        kind?: Docs.Kind;
-        methods?: Docs.Methods.Item[];
-        version?: string;
-    }
-    namespace Docs {
-        const Kind: {
-            readonly Dev: "dev";
-            readonly User: "user";
-        };
-        type Kind = (typeof Kind)[keyof typeof Kind];
-        type Methods = Methods.Item[];
-        namespace Methods {
-            interface Item {
-                name?: string;
-                description?: string;
-                params?: Record<string, unknown>;
-                returns?: Record<string, unknown>;
-            }
-        }
-    }
-    /**
-     * Contract attributes
-     */
-    interface Attributes {
-        useCases?: string[];
-        standards?: string[];
-        auditor?: Attributes.Auditor;
-    }
-    namespace Attributes {
-        interface Auditor {
-            name?: string;
-            imageURL?: string;
-            link?: string;
-        }
-    }
+
+type index$4_GetAddressForOrganizationRequest = GetAddressForOrganizationRequest;
+type index$4_GetAddressForProfileRequest = GetAddressForProfileRequest;
+declare namespace index$4 {
+  export {
+    index$4_GetAddressForOrganizationRequest as GetAddressForOrganizationRequest,
+    index$4_GetAddressForProfileRequest as GetAddressForProfileRequest,
+  };
 }
 
 /**
  * @example
  *     {
- *         functionSignature: "functionSignature"
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface GetTemplateFunctionsRequest {
-    /** Function signature to filter by */
-    functionSignature?: string;
+interface GetTransactionsByAddressRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
 /**
  * @example
  *     {
- *         network: "network",
- *         addressId: "addressId",
- *         clientShare: "clientShare"
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface DeployContractRequest {
-    /** Target network */
-    network: string;
-    /** Address ID for deployment */
-    addressId: string;
-    /** Client share for signing */
-    clientShare: string;
-    /** Constructor parameters */
-    constructorParameters?: DeployContractRequest.ConstructorParameters.Item[];
-}
-declare namespace DeployContractRequest {
-    type ConstructorParameters = ConstructorParameters.Item[];
-    namespace ConstructorParameters {
-        interface Item {
-            /** Parameter name */
-            name: string;
-            /** Parameter description */
-            description?: string;
-            /** Internal parameter type */
-            internalType?: string;
-            /** Parameter type */
-            type: string;
-            /** Parameter components */
-            components?: Record<string, unknown>[];
-            /** Parameter value */
-            value?: string;
-        }
-    }
-}
-
-declare const index$4_CreateContractTemplateRequest: typeof CreateContractTemplateRequest;
-declare const index$4_DeployContractRequest: typeof DeployContractRequest;
-type index$4_GetContractTemplatesRequest = GetContractTemplatesRequest;
-type index$4_GetTemplateFunctionsRequest = GetTemplateFunctionsRequest;
-declare namespace index$4 {
-  export {
-    index$4_CreateContractTemplateRequest as CreateContractTemplateRequest,
-    index$4_DeployContractRequest as DeployContractRequest,
-    index$4_GetContractTemplatesRequest as GetContractTemplatesRequest,
-    index$4_GetTemplateFunctionsRequest as GetTemplateFunctionsRequest,
-  };
+interface GetTransactionsByMiniWalletRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
 /**
  * @example
  *     {
- *         abiFunction: {
- *             name: "name",
- *             inputs: [{}],
- *             outputs: [{}],
- *             type: "type"
- *         }
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface ReadFunctionRequest {
-    /** ABI function definition */
-    abiFunction: ReadFunctionRequest.AbiFunction;
-}
-declare namespace ReadFunctionRequest {
-    /**
-     * ABI function definition
-     */
-    interface AbiFunction {
-        /** Function name */
-        name: string;
-        /** Function input parameters */
-        inputs: AbiFunction.Inputs.Item[];
-        /** Function output parameters */
-        outputs: AbiFunction.Outputs.Item[];
-        stateMutability?: string;
-        type: string;
-    }
-    namespace AbiFunction {
-        type Inputs = Inputs.Item[];
-        namespace Inputs {
-            interface Item {
-                name?: string;
-                type?: string;
-                internalType?: string;
-            }
-        }
-        type Outputs = Outputs.Item[];
-        namespace Outputs {
-            interface Item {
-                name?: string;
-                type?: string;
-                internalType?: string;
-            }
-        }
-    }
+interface GetTransactionsByOrganizationRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
 /**
  * @example
  *     {
- *         addressId: "addressId",
- *         clientShare: "clientShare",
- *         abiFunction: {
- *             name: "name",
- *             inputs: [{}],
- *             outputs: [{}],
- *             type: "type"
- *         }
+ *         skip: 1,
+ *         take: 1
  *     }
  */
-interface WriteFunctionRequest {
-    /** Address ID for transaction */
-    addressId: string;
-    /** Client share for signing */
-    clientShare: string;
-    /** ABI function definition */
-    abiFunction: WriteFunctionRequest.AbiFunction;
-    /** ETH value to send */
-    amount?: string;
-    /** Fee level for transaction */
-    feeLevel?: WriteFunctionRequest.FeeLevel;
-}
-declare namespace WriteFunctionRequest {
-    /**
-     * ABI function definition
-     */
-    interface AbiFunction {
-        /** Function name */
-        name: string;
-        /** Function input parameters */
-        inputs: AbiFunction.Inputs.Item[];
-        /** Function output parameters */
-        outputs: AbiFunction.Outputs.Item[];
-        stateMutability?: string;
-        type: string;
-    }
-    namespace AbiFunction {
-        type Inputs = Inputs.Item[];
-        namespace Inputs {
-            interface Item {
-                name?: string;
-                type?: string;
-                internalType?: string;
-            }
-        }
-        type Outputs = Outputs.Item[];
-        namespace Outputs {
-            interface Item {
-                name?: string;
-                type?: string;
-                internalType?: string;
-            }
-        }
-    }
-    /** Fee level for transaction */
-    const FeeLevel: {
-        readonly Low: "LOW";
-        readonly Medium: "MEDIUM";
-        readonly High: "HIGH";
-    };
-    type FeeLevel = (typeof FeeLevel)[keyof typeof FeeLevel];
+interface GetTransactionsByProfileRequest {
+    /** Number of records to skip */
+    skip?: number;
+    /** Number of records to take */
+    take?: number;
 }
 
-declare const index$3_ReadFunctionRequest: typeof ReadFunctionRequest;
-declare const index$3_WriteFunctionRequest: typeof WriteFunctionRequest;
+type index$3_GetTransactionsByAddressRequest = GetTransactionsByAddressRequest;
+type index$3_GetTransactionsByMiniWalletRequest = GetTransactionsByMiniWalletRequest;
+type index$3_GetTransactionsByOrganizationRequest = GetTransactionsByOrganizationRequest;
+type index$3_GetTransactionsByProfileRequest = GetTransactionsByProfileRequest;
 declare namespace index$3 {
   export {
-    index$3_ReadFunctionRequest as ReadFunctionRequest,
-    index$3_WriteFunctionRequest as WriteFunctionRequest,
+    index$3_GetTransactionsByAddressRequest as GetTransactionsByAddressRequest,
+    index$3_GetTransactionsByMiniWalletRequest as GetTransactionsByMiniWalletRequest,
+    index$3_GetTransactionsByOrganizationRequest as GetTransactionsByOrganizationRequest,
+    index$3_GetTransactionsByProfileRequest as GetTransactionsByProfileRequest,
   };
 }
 
@@ -903,143 +771,1070 @@ declare namespace index$2 {
 /**
  * @example
  *     {
- *         address: "address",
- *         walletId: "walletId",
- *         contractAddress: "contractAddress",
- *         tokenizationId: "tokenizationId",
- *         skip: 1,
- *         take: 1
+ *         to: "to",
+ *         amount: "amount",
+ *         from: ["from"],
+ *         network: "tBTC",
+ *         clientShare: "clientShare"
  *     }
  */
-interface GetAssetsRequest {
-    /** Blockchain address to filter by */
-    address?: string;
-    /** Wallet ID to filter by */
-    walletId?: string;
-    /** Contract address to filter by */
-    contractAddress?: string;
-    /** Tokenization ID to filter by */
-    tokenizationId?: string;
-    /** Number of records to skip */
-    skip?: number;
-    /** Number of records to take */
-    take?: number;
+interface CreateWithdrawRequest {
+    to: string;
+    amount: string;
+    from: string[];
+    network: CreateWithdrawRequest.Network;
+    clientShare: string;
+}
+declare namespace CreateWithdrawRequest {
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
 }
 
-type index$1_GetAssetsRequest = GetAssetsRequest;
+declare const index$1_CreateWithdrawRequest: typeof CreateWithdrawRequest;
 declare namespace index$1 {
   export {
-    index$1_GetAssetsRequest as GetAssetsRequest,
+    index$1_CreateWithdrawRequest as CreateWithdrawRequest,
   };
 }
 
-interface TemporalWorkflowStatusData {
-    /** Temporal workflow ID */
-    workflowId: string;
-    /** Temporal run ID */
-    runId?: string;
-    /** Workflow execution status */
-    status: string;
-    /** Workflow start time (ISO 8601) */
-    startTime: string;
-    /** Workflow close time (ISO 8601) or null if running */
-    closeTime?: string;
-    /** Execution time (implementation-defined units) */
-    executionTime?: number;
-    /** Number of events in workflow history */
-    historyLength: number;
-    /** Workflow result payload if completed */
-    result?: Record<string, unknown>;
-    /** Error information if the workflow failed */
-    error?: Record<string, unknown>;
-}
-
-interface LinkedTokenData {
-    id: string;
-    linked: boolean;
-    collectionId?: string;
-}
-
-interface LinkedTokenResponse {
-    data: LinkedTokenData;
-    /** Response message */
-    message: string;
-    /** Indicates successful response */
-    success: boolean;
-    /** HTTP status code */
-    status: number;
-}
-
-interface SuccessResponse {
-    /** Response message */
-    message: string;
-    /** Response data */
-    data?: Record<string, unknown>;
-    /** Indicates successful response */
-    success: boolean;
-    /** HTTP status code */
-    status: number;
-}
-
+/**
+ * Error response object
+ */
 interface ErrorResponse {
-    /** Error message */
+    /** Human-readable error message */
     message: string;
-    /** Array of field-specific errors */
-    errors?: ErrorResponse.Errors.Item[];
-    /** Indicates failed response */
-    success: boolean;
+    /** Error code for programmatic error handling */
+    code: string;
+    category: ErrorResponse.Category;
     /** HTTP status code */
-    status: number;
+    statusCode: number;
+    /** API path where error occurred */
+    path: string;
+    /** Timestamp when error occurred (ISO 8601) */
+    timestamp: string;
+    /** Unique request identifier for tracking and debugging */
+    requestId?: string;
+    /** Array of field-specific validation errors (only present for validation errors) */
+    errors?: ErrorResponse.Errors.Item[];
 }
 declare namespace ErrorResponse {
+    const Category: {
+        readonly Conflict: "CONFLICT";
+        readonly Validation: "VALIDATION";
+        readonly Cryptographic: "CRYPTOGRAPHIC";
+        readonly Network: "NETWORK";
+        readonly Database: "DATABASE";
+        readonly ExternalService: "EXTERNAL_SERVICE";
+        readonly UnknownError: "UNKNOWN_ERROR";
+        readonly Resource: "RESOURCE";
+    };
+    type Category = (typeof Category)[keyof typeof Category];
     type Errors = Errors.Item[];
     namespace Errors {
         interface Item {
             /** Field name that caused the error */
-            field?: string;
+            field: string;
             /** Error message for the field */
-            message?: string;
+            message: string;
         }
     }
 }
 
-interface PaginatedResponse extends SuccessResponse {
-    pagination?: PaginatedResponse.Pagination;
+/**
+ * Profile response object
+ */
+interface ProfileResponse {
+    data?: ProfileResponse.Data;
 }
-declare namespace PaginatedResponse {
-    interface Pagination {
-        /** Number of records skipped */
-        skip: number;
-        /** Number of records taken */
-        take: number;
-        /** Total number of elements */
-        totalElements: number;
-        /** Total number of pages */
-        totalPages: number;
+declare namespace ProfileResponse {
+    interface Data {
+        reference?: string;
+        type?: string;
     }
 }
 
-interface CreateAddressRequest {
-    /** Profile reference */
-    reference: string;
-    /** Blockchain network */
-    network: CreateAddressRequest.Network;
-    /** Client share for signing */
-    clientShare: string;
+/**
+ * Profiles response object
+ */
+interface ProfilesResponse {
+    data?: ProfilesResponse.Data.Item[];
+    pagination?: Pagination;
 }
-declare namespace CreateAddressRequest {
-    /** Blockchain network */
+declare namespace ProfilesResponse {
+    type Data = Data.Item[];
+    namespace Data {
+        interface Item {
+            reference?: string;
+            type?: string;
+        }
+    }
+}
+
+/**
+ * Wallet data object
+ */
+interface WalletData {
+    id?: string;
+    date?: string;
+    organizationId?: string;
+    reference?: string;
+    type?: string;
+    network?: WalletData.Network;
+    currentDeepIndex?: number;
+    index?: number;
+    path?: string;
+}
+declare namespace WalletData {
     const Network: {
-        readonly Btc: "BTC";
         readonly TBtc: "tBTC";
-        readonly Eth: "ETH";
         readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
     };
     type Network = (typeof Network)[keyof typeof Network];
 }
 
 /**
- * The raw response from the fetch call excluding the body.
+ * Wallet response object
+ */
+interface WalletResponse {
+    data?: WalletData;
+}
+
+/**
+ * Wallets response object
+ */
+interface WalletsResponse {
+    data?: WalletData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Create address request object
+ */
+interface CreateAddressRequest {
+    /** Profile reference */
+    reference: string;
+    /** Blockchain network */
+    network: CreateAddressRequest.Network;
+    /** Client share for wallet derivation */
+    clientShare: string;
+}
+declare namespace CreateAddressRequest {
+    /** Blockchain network */
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+}
+
+/**
+ * Address data object
+ */
+interface AddressData {
+    address?: string;
+    date?: string;
+    label?: string;
+    sub?: string;
+    network?: AddressData.Network;
+    /** Balance as decimal string */
+    balance?: string;
+    reference?: string;
+    path?: string;
+    id?: string;
+    miniWalletId?: string;
+}
+declare namespace AddressData {
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+}
+
+/**
+ * Create address response object
+ */
+interface CreateAddressResponse {
+    /** Generated address */
+    data?: string;
+    message?: string;
+}
+
+/**
+ * Addresses response object
+ */
+interface AddressesResponse {
+    data?: AddressData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Transaction data object
+ */
+interface TransactionData {
+    addressFrom?: string;
+    addressTo?: string;
+    /** Transaction amount as decimal string */
+    amount?: string;
+    date?: string;
+    isMempool?: boolean;
+    isSpent?: boolean;
+    status?: TransactionData.Status;
+    updatedAt?: string;
+    createdAt?: string;
+    type?: TransactionData.Type;
+    network?: TransactionData.Network;
+    txid?: string;
+    contractAddress?: string;
+    tokenId?: string;
+    txType?: string;
+    /** Transaction fee as decimal string */
+    fee?: string;
+}
+declare namespace TransactionData {
+    const Status: {
+        readonly Pending: "Pending";
+        readonly Confirmed: "Confirmed";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+    const Type: {
+        readonly Withdraw: "Withdraw";
+        readonly Deposit: "Deposit";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+}
+
+/**
+ * Transactions response object
+ */
+interface TransactionsResponse {
+    data?: TransactionData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Transactions by profile response object
+ */
+interface TransactionsByProfileResponse {
+    transactions?: TransactionData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Asset data object
+ */
+interface AssetData {
+    id?: string;
+    /** Asset amount as decimal string */
+    amount?: string;
+    walletId?: string;
+    addressId?: string;
+    tokenizationId?: string;
+    tokenId?: string;
+    name?: string;
+    symbol?: string;
+    contractAddress?: string;
+    updatedAt?: string;
+    createdAt?: string;
+}
+
+/**
+ * Assets response object
+ */
+interface AssetsResponse {
+    assets?: AssetData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Native balance data object
+ */
+interface NativeBalanceData {
+    id?: string;
+    walletId?: string;
+    addressId?: string;
+    network?: NativeBalanceData.Network;
+    symbol?: string;
+    /** Balance amount as decimal string */
+    amount?: string;
+    decimals?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+declare namespace NativeBalanceData {
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+}
+
+/**
+ * Native balance response object
+ */
+interface NativeBalanceResponse {
+    balance?: NativeBalanceData[];
+    pagination?: Pagination;
+}
+
+/**
+ * Temporal workflow error
+ */
+interface TemporalWorkflowError {
+    message?: string;
+    type?: string;
+}
+
+/**
+ * Temporal workflow status data object
+ */
+interface TemporalWorkflowStatusData {
+    /** Temporal workflow ID */
+    workflowId: string;
+    /** Temporal workflow run ID */
+    runId: string;
+    /** Workflow status */
+    status: TemporalWorkflowStatusData.Status;
+    /** Workflow start time in ISO 8601 format */
+    startTime: string;
+    /** Workflow close time in ISO 8601 format (null if still running) */
+    closeTime?: string;
+    /** Workflow execution time in milliseconds (null if still running) */
+    executionTime?: number;
+    /** Number of events in workflow history */
+    historyLength: number;
+    /** Workflow result (only present if workflow is completed) */
+    result?: Record<string, unknown>;
+    /** Workflow error (only present if workflow failed) */
+    error?: TemporalWorkflowError;
+}
+declare namespace TemporalWorkflowStatusData {
+    /** Workflow status */
+    const Status: {
+        readonly Running: "RUNNING";
+        readonly Completed: "COMPLETED";
+        readonly Failed: "FAILED";
+        readonly Canceled: "CANCELED";
+        readonly Terminated: "TERMINATED";
+        readonly ContinuedAsNew: "CONTINUED_AS_NEW";
+        readonly TimedOut: "TIMED_OUT";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+}
+
+/**
+ * Pagination
+ */
+interface Pagination {
+    /** Total number of elements */
+    totalElements: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Number of records skipped */
+    skip: number;
+    /** Number of records taken */
+    take: number;
+}
+
+/**
+ * Token response object
+ */
+interface TokenResponse {
+    token?: TokenResponse.Token;
+}
+declare namespace TokenResponse {
+    interface Token {
+        id?: string;
+        organizationId?: string;
+        sub?: string;
+        name?: string;
+        symbol?: string;
+        decimals?: number;
+        description?: string;
+        type?: string;
+        contractAddress?: string;
+        contractTemplateId?: string;
+        contractDeploymentId?: string;
+        network?: Token.Network;
+        addressId?: string;
+        customerRefId?: string;
+        tags?: string[];
+        status?: string;
+        createdAt?: string;
+        updatedAt?: string;
+    }
+    namespace Token {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Tokens response object
+ */
+interface TokensResponse {
+    token?: TokensResponse.Token;
+}
+declare namespace TokensResponse {
+    interface Token {
+        tokens?: TokenData[];
+        total?: number;
+    }
+}
+
+/**
+ * Workflow response object
+ */
+interface WorkflowResponse {
+    workflowId?: string;
+    status?: string;
+}
+
+/**
+ * Collections response object
+ */
+interface CollectionsResponse {
+    collections?: CollectionData[];
+    total?: number;
+    message?: string;
+}
+
+/**
+ * Collection response object
+ */
+interface CollectionResponse {
+    collection?: CollectionData;
+}
+
+/**
+ * Collection token details response object
+ */
+interface CollectionTokenDetailsResponse {
+    collcetion?: CollectionTokenDetailsResponse.Collcetion;
+}
+declare namespace CollectionTokenDetailsResponse {
+    interface Collcetion {
+        id?: string;
+        collectionId?: string;
+        name?: string;
+        symbol?: string;
+        network?: Collcetion.Network;
+        addressId?: string;
+        contractAddress?: string;
+        status?: Collcetion.Status;
+        recipientAddress?: string;
+        mintTransactionHash?: string;
+        burnTransactionHash?: string;
+        mintedAt?: string;
+        burnedAt?: string;
+        metadata?: Collcetion.Metadata;
+        mintRecord?: Collcetion.MintRecord;
+        burnRecord?: Collcetion.BurnRecord;
+    }
+    namespace Collcetion {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+        const Status: {
+            readonly Active: "ACTIVE";
+            readonly Burned: "BURNED";
+        };
+        type Status = (typeof Status)[keyof typeof Status];
+        interface Metadata {
+            name?: string;
+            description?: string;
+            image?: string;
+            animation_url?: string;
+            external_url?: string;
+            attributes?: Metadata.Attributes.Item[];
+        }
+        namespace Metadata {
+            type Attributes = Attributes.Item[];
+            namespace Attributes {
+                interface Item {
+                    trait_type?: string;
+                    value?: string;
+                    display_type?: string;
+                }
+            }
+        }
+        interface MintRecord {
+            id?: string;
+            amount?: string;
+            note?: string;
+            status?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }
+        interface BurnRecord {
+            id?: string;
+            amount?: string;
+            note?: string;
+            status?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }
+    }
+}
+
+/**
+ * Collection tokens response object
+ */
+interface CollectionTokensResponse {
+    tokens?: CollectionTokenData[];
+    total?: number;
+}
+
+/**
+ * Contract template response object
+ */
+interface ContractTemplateResponse {
+    contract?: ContractTemplateResponse.Contract;
+}
+declare namespace ContractTemplateResponse {
+    interface Contract {
+        id?: string;
+        name?: string;
+        description?: string;
+        longDescription?: string;
+        bytecode?: string;
+        sourceCode?: string;
+        type?: string;
+        docs?: Record<string, unknown>;
+    }
+}
+
+/**
+ * Contract templates response object
+ */
+interface ContractTemplatesResponse {
+    result?: ContractTemplatesResponse.Result;
+}
+declare namespace ContractTemplatesResponse {
+    interface Result {
+        data?: ContractTemplateData[];
+        next?: number;
+        count?: number;
+    }
+}
+
+/**
+ * Contract constructor response object
+ */
+interface ContractConstructorResponse {
+    contractConstructor?: ContractConstructorResponse.ContractConstructor;
+}
+declare namespace ContractConstructorResponse {
+    interface ContractConstructor {
+        id?: string;
+        stateMutability?: ContractConstructor.StateMutability;
+        type?: ContractConstructor.Type;
+        inputs?: Record<string, unknown>[];
+        outputs?: Record<string, unknown>[];
+    }
+    namespace ContractConstructor {
+        const StateMutability: {
+            readonly Pure: "pure";
+            readonly View: "view";
+            readonly Nonpayable: "nonpayable";
+            readonly Payable: "payable";
+        };
+        type StateMutability = (typeof StateMutability)[keyof typeof StateMutability];
+        const Type: {
+            readonly Function: "function";
+            readonly Constructor: "constructor";
+            readonly Event: "event";
+            readonly Error: "error";
+            readonly Fallback: "fallback";
+            readonly Receive: "receive";
+        };
+        type Type = (typeof Type)[keyof typeof Type];
+    }
+}
+
+/**
+ * Contract functions response object
+ */
+interface ContractFunctionsResponse {
+    contractFunction?: ContractFunctionsResponse.ContractFunction.Item[];
+}
+declare namespace ContractFunctionsResponse {
+    type ContractFunction = ContractFunction.Item[];
+    namespace ContractFunction {
+        interface Item {
+            id?: string;
+            name?: string;
+            stateMutability?: Item.StateMutability;
+            type?: Item.Type;
+            inputs?: Record<string, unknown>[];
+            outputs?: Record<string, unknown>[];
+        }
+        namespace Item {
+            const StateMutability: {
+                readonly Pure: "pure";
+                readonly View: "view";
+                readonly Nonpayable: "nonpayable";
+                readonly Payable: "payable";
+            };
+            type StateMutability = (typeof StateMutability)[keyof typeof StateMutability];
+            const Type: {
+                readonly Function: "function";
+                readonly Constructor: "constructor";
+                readonly Event: "event";
+                readonly Error: "error";
+                readonly Fallback: "fallback";
+                readonly Receive: "receive";
+            };
+            type Type = (typeof Type)[keyof typeof Type];
+        }
+    }
+}
+
+/**
+ * Deployed contracts response object
+ */
+interface DeployedContractsResponse {
+    deployedContracts?: DeployedContractsResponse.DeployedContracts;
+}
+declare namespace DeployedContractsResponse {
+    interface DeployedContracts {
+        contracts?: DeployedContractData[];
+        total?: number;
+        skip?: number;
+        take?: number;
+    }
+}
+
+/**
+ * Deployed contract response object
+ */
+interface DeployedContractResponse {
+    deployedContract?: Record<string, unknown>;
+}
+
+/**
+ * Contract abi response object
+ */
+interface ContractAbiResponse {
+    contractAbi?: ContractAbiResponse.ContractAbi;
+}
+declare namespace ContractAbiResponse {
+    interface ContractAbi {
+        abi?: Record<string, unknown>[];
+        contractAddress?: string;
+        network?: ContractAbi.Network;
+        implementationAddress?: string;
+        status?: string;
+        source?: string;
+    }
+    namespace ContractAbi {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Add contract abi response object
+ */
+interface AddContractAbiResponse {
+    result?: AddContractAbiResponse.Result;
+}
+declare namespace AddContractAbiResponse {
+    interface Result {
+        contractAddress?: string;
+        network?: Result.Network;
+        name?: string;
+        abi?: Record<string, unknown>[];
+        status?: string;
+        source?: string;
+        message?: string;
+        tenantId?: string;
+        userId?: string;
+    }
+    namespace Result {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Read call function response object
+ */
+interface ReadCallFunctionResponse {
+    result?: ReadCallFunctionResponse.Result;
+}
+declare namespace ReadCallFunctionResponse {
+    interface Result {
+        data?: Result.Data;
+        success?: boolean;
+        status?: number;
+    }
+    namespace Result {
+        interface Data {
+            /** Decoded function result */
+            result?: Record<string, unknown>;
+            functionName?: string;
+            contractAddress?: string;
+            network?: Data.Network;
+            encodedData?: string;
+        }
+        namespace Data {
+            const Network: {
+                readonly TBtc: "tBTC";
+                readonly TEth: "tETH";
+                readonly Avax: "AVAX";
+                readonly Fuji: "FUJI";
+                readonly Sandbox: "SANDBOX";
+            };
+            type Network = (typeof Network)[keyof typeof Network];
+        }
+    }
+}
+
+/**
+ * Transaction receipt response object
+ */
+interface TransactionReceiptResponse {
+    /** Transaction receipt object from blockchain */
+    receipt?: TransactionReceiptResponse.Receipt;
+}
+declare namespace TransactionReceiptResponse {
+    /**
+     * Transaction receipt object from blockchain
+     */
+    interface Receipt {
+        transactionHash?: string;
+        blockNumber?: number;
+        blockHash?: string;
+        transactionIndex?: number;
+        from?: string;
+        to?: string;
+        gasUsed?: string;
+        effectiveGasPrice?: string;
+        status?: number;
+        logs?: Record<string, unknown>[];
+    }
+}
+
+/**
+ * Withdraw response object
+ */
+interface WithdrawResponse {
+    data?: WithdrawResponse.Data;
+}
+declare namespace WithdrawResponse {
+    interface Data {
+        id?: string;
+        status?: string;
+        hash?: string;
+    }
+}
+
+/**
+ * Token data object
+ */
+interface TokenData {
+    id?: string;
+    status?: string;
+    type?: string;
+    displayName?: string;
+    tokenMetadata?: TokenData.TokenMetadata;
+}
+declare namespace TokenData {
+    interface TokenMetadata {
+        name?: string;
+        symbol?: string;
+        decimals?: number;
+        standard?: string;
+        network?: TokenMetadata.Network;
+        contractAddress?: string;
+        contractTemplateId?: string;
+        contractDeploymentId?: string;
+        addressId?: string;
+    }
+    namespace TokenMetadata {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Collection data object
+ */
+interface CollectionData {
+    id?: string;
+    status?: string;
+    type?: string;
+    displayName?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    network?: CollectionData.Network;
+    collectionMetadata?: CollectionData.CollectionMetadata;
+}
+declare namespace CollectionData {
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+    interface CollectionMetadata {
+        name?: string;
+        symbol?: string;
+        standard?: string;
+        contractAddress?: string;
+    }
+}
+
+/**
+ * Collection token data object
+ */
+interface CollectionTokenData {
+    id?: string;
+    status?: string;
+    type?: CollectionTokenData.Type;
+    metaData?: Record<string, unknown>;
+    addressId?: string;
+    amount?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    transactionHash?: string;
+    tokenId?: string;
+}
+declare namespace CollectionTokenData {
+    const Type: {
+        readonly Mint: "MINT";
+        readonly Burn: "BURN";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}
+
+/**
+ * Contract template function
+ */
+interface ContractTemplateFunction {
+    name?: string;
+    stateMutability?: ContractTemplateFunction.StateMutability;
+    type?: ContractTemplateFunction.Type;
+    inputs?: Record<string, unknown>[];
+    outputs?: Record<string, unknown>[];
+    description?: string;
+}
+declare namespace ContractTemplateFunction {
+    const StateMutability: {
+        readonly Pure: "pure";
+        readonly View: "view";
+        readonly Nonpayable: "nonpayable";
+        readonly Payable: "payable";
+    };
+    type StateMutability = (typeof StateMutability)[keyof typeof StateMutability];
+    const Type: {
+        readonly Function: "function";
+        readonly Constructor: "constructor";
+        readonly Event: "event";
+        readonly Error: "error";
+        readonly Fallback: "fallback";
+        readonly Receive: "receive";
+    };
+    type Type = (typeof Type)[keyof typeof Type];
+}
+
+/**
+ * Contract template data object
+ */
+interface ContractTemplateData {
+    id?: string;
+    organizationId?: string;
+    name?: string;
+    description?: string;
+    longDescription?: string;
+    bytecode?: string;
+    sourceCode?: string;
+    type?: string;
+    docs?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+    abi?: ContractTemplateFunction[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+
+/**
+ * Contract template by id response object
+ */
+interface ContractTemplateByIdResponse {
+    result?: ContractTemplateData;
+}
+
+/**
+ * Deployed contract data object
+ */
+interface DeployedContractData {
+    id?: string;
+    contractAddress?: string;
+    network?: DeployedContractData.Network;
+    contractTemplateId?: string;
+}
+declare namespace DeployedContractData {
+    const Network: {
+        readonly TBtc: "tBTC";
+        readonly TEth: "tETH";
+        readonly Avax: "AVAX";
+        readonly Fuji: "FUJI";
+        readonly Sandbox: "SANDBOX";
+    };
+    type Network = (typeof Network)[keyof typeof Network];
+}
+
+/**
+ * Deployed contract by id response object
+ */
+interface DeployedContractByIdResponse {
+    deployedContract?: DeployedContractByIdResponse.DeployedContract;
+}
+declare namespace DeployedContractByIdResponse {
+    interface DeployedContract {
+        id?: string;
+        contractAddress?: string;
+        network?: DeployedContract.Network;
+        contractTemplateId?: string;
+        deployerAddressId?: string;
+    }
+    namespace DeployedContract {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Deployed contract by address response object
+ */
+interface DeployedContractByAddressResponse {
+    deployedContract?: DeployedContractByAddressResponse.DeployedContract;
+}
+declare namespace DeployedContractByAddressResponse {
+    interface DeployedContract {
+        id?: string;
+        contractAddress?: string;
+        network?: DeployedContract.Network;
+        contractTemplateId?: string;
+        vauldAccountId?: string;
+    }
+    namespace DeployedContract {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+    }
+}
+
+/**
+ * Fetch contract abi response object
+ */
+interface FetchContractAbiResponse {
+    contractAbi?: FetchContractAbiResponse.ContractAbi;
+}
+declare namespace FetchContractAbiResponse {
+    interface ContractAbi {
+        abi?: Record<string, unknown>[];
+        contractAddress?: string;
+        network?: ContractAbi.Network;
+        status?: string;
+        source?: ContractAbi.Source;
+        tenantId?: string;
+        userId?: string;
+    }
+    namespace ContractAbi {
+        const Network: {
+            readonly TBtc: "tBTC";
+            readonly TEth: "tETH";
+            readonly Avax: "AVAX";
+            readonly Fuji: "FUJI";
+            readonly Sandbox: "SANDBOX";
+        };
+        type Network = (typeof Network)[keyof typeof Network];
+        const Source: {
+            readonly TenantDatabase: "tenant_database";
+            readonly Database: "database";
+            readonly Blockchain: "blockchain";
+        };
+        type Source = (typeof Source)[keyof typeof Source];
+    }
+}
+
+/**
+ * Issue new token response object
+ */
+type IssueNewTokenResponse = TokenData;
+
+/**
+ * The raw response from the fetch call excluding the body.
  */
 type RawResponse = Omit<{
     [K in keyof Response as Response[K] extends Function ? never : K]: Response[K];
@@ -1141,107 +1936,271 @@ declare class BadRequestError extends OumlaSdkApiError {
     constructor(body: ErrorResponse, rawResponse?: RawResponse);
 }
 
+declare class UnauthorizedError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class InternalServerError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class ForbiddenError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class ConflictError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class UnprocessableEntityError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
 declare class NotFoundError extends OumlaSdkApiError {
     constructor(body: ErrorResponse, rawResponse?: RawResponse);
 }
 
+declare class BadGatewayError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class ServiceUnavailableError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
+declare class GatewayTimeoutError extends OumlaSdkApiError {
+    constructor(body: ErrorResponse, rawResponse?: RawResponse);
+}
+
 type index_AddContractAbiRequest = AddContractAbiRequest;
+declare const index_AddContractAbiResponse: typeof AddContractAbiResponse;
+declare const index_AddressData: typeof AddressData;
+type index_AddressesResponse = AddressesResponse;
+type index_AssetData = AssetData;
+type index_AssetsResponse = AssetsResponse;
+type index_BadGatewayError = BadGatewayError;
+declare const index_BadGatewayError: typeof BadGatewayError;
 type index_BadRequestError = BadRequestError;
 declare const index_BadRequestError: typeof BadRequestError;
 type index_BurnTokenRequest = BurnTokenRequest;
+declare const index_BurnTokenResponse: typeof BurnTokenResponse;
+declare const index_CollectionData: typeof CollectionData;
+type index_CollectionResponse = CollectionResponse;
+declare const index_CollectionTokenData: typeof CollectionTokenData;
+declare const index_CollectionTokenDetailsResponse: typeof CollectionTokenDetailsResponse;
+type index_CollectionTokensResponse = CollectionTokensResponse;
+type index_CollectionsResponse = CollectionsResponse;
+type index_ConflictError = ConflictError;
+declare const index_ConflictError: typeof ConflictError;
+declare const index_ContractAbiResponse: typeof ContractAbiResponse;
+declare const index_ContractConstructorResponse: typeof ContractConstructorResponse;
+declare const index_ContractFunctionsResponse: typeof ContractFunctionsResponse;
+type index_ContractTemplateByIdResponse = ContractTemplateByIdResponse;
+type index_ContractTemplateData = ContractTemplateData;
+declare const index_ContractTemplateFunction: typeof ContractTemplateFunction;
+declare const index_ContractTemplateResponse: typeof ContractTemplateResponse;
+declare const index_ContractTemplatesResponse: typeof ContractTemplatesResponse;
 declare const index_CreateAddressRequest: typeof CreateAddressRequest;
-declare const index_CreateCollectionRequest: typeof CreateCollectionRequest;
-declare const index_CreateContractTemplateRequest: typeof CreateContractTemplateRequest;
+type index_CreateAddressResponse = CreateAddressResponse;
+type index_CreateCollectionRequest = CreateCollectionRequest;
+type index_CreateContractRequest = CreateContractRequest;
 declare const index_CreateProfileRequest: typeof CreateProfileRequest;
 declare const index_CreateWalletRequest: typeof CreateWalletRequest;
-declare const index_CreateWithdrawalRequest: typeof CreateWithdrawalRequest;
-declare const index_DeployContractRequest: typeof DeployContractRequest;
+declare const index_CreateWithdrawRequest: typeof CreateWithdrawRequest;
+type index_DeployContractRequest = DeployContractRequest;
+declare const index_DeployContractResponse: typeof DeployContractResponse;
+declare const index_DeployedContractByAddressResponse: typeof DeployedContractByAddressResponse;
+declare const index_DeployedContractByIdResponse: typeof DeployedContractByIdResponse;
+declare const index_DeployedContractData: typeof DeployedContractData;
+type index_DeployedContractResponse = DeployedContractResponse;
+declare const index_DeployedContractsResponse: typeof DeployedContractsResponse;
 declare const index_ErrorResponse: typeof ErrorResponse;
 type index_FetchContractAbiRequest = FetchContractAbiRequest;
+declare const index_FetchContractAbiResponse: typeof FetchContractAbiResponse;
+type index_ForbiddenError = ForbiddenError;
+declare const index_ForbiddenError: typeof ForbiddenError;
+type index_GatewayTimeoutError = GatewayTimeoutError;
+declare const index_GatewayTimeoutError: typeof GatewayTimeoutError;
+type index_GetAddressForOrganizationRequest = GetAddressForOrganizationRequest;
+type index_GetAddressForProfileRequest = GetAddressForProfileRequest;
 type index_GetAssetsRequest = GetAssetsRequest;
 type index_GetCollectionTokensRequest = GetCollectionTokensRequest;
-type index_GetCollectionTokensRequestType = GetCollectionTokensRequestType;
 type index_GetCollectionsRequest = GetCollectionsRequest;
-type index_GetContractTemplatesRequest = GetContractTemplatesRequest;
+type index_GetContractsRequest = GetContractsRequest;
+type index_GetDeployedContractAbiRequestNetwork = GetDeployedContractAbiRequestNetwork;
+type index_GetDeployedContractByAddressRequestNetwork = GetDeployedContractByAddressRequestNetwork;
 type index_GetDeployedContractsRequest = GetDeployedContractsRequest;
 type index_GetDeployedContractsRequestNetwork = GetDeployedContractsRequestNetwork;
-type index_GetOrganizationAddressesRequest = GetOrganizationAddressesRequest;
-type index_GetOrganizationTransactionsRequest = GetOrganizationTransactionsRequest;
-type index_GetOrganizationWalletsRequest = GetOrganizationWalletsRequest;
-type index_GetProfileAddressesRequest = GetProfileAddressesRequest;
-type index_GetProfileTransactionsRequest = GetProfileTransactionsRequest;
-type index_GetProfileWalletsRequest = GetProfileWalletsRequest;
+type index_GetLinkedTokenResponse = GetLinkedTokenResponse;
+type index_GetNativeBalanceRequest = GetNativeBalanceRequest;
+type index_GetNativeBalanceRequestNetwork = GetNativeBalanceRequestNetwork;
 type index_GetProfilesRequest = GetProfilesRequest;
-type index_GetTemplateFunctionsRequest = GetTemplateFunctionsRequest;
 type index_GetTokensRequest = GetTokensRequest;
+type index_GetTransactionReceiptRequestNetwork = GetTransactionReceiptRequestNetwork;
 type index_GetTransactionsByAddressRequest = GetTransactionsByAddressRequest;
-type index_GetTransactionsByWalletRequest = GetTransactionsByWalletRequest;
+type index_GetTransactionsByMiniWalletRequest = GetTransactionsByMiniWalletRequest;
+type index_GetTransactionsByOrganizationRequest = GetTransactionsByOrganizationRequest;
+type index_GetTransactionsByProfileRequest = GetTransactionsByProfileRequest;
+type index_GetWalletsByProfileRequest = GetWalletsByProfileRequest;
+type index_GetWalletsForOrganizationRequest = GetWalletsForOrganizationRequest;
+type index_InternalServerError = InternalServerError;
+declare const index_InternalServerError: typeof InternalServerError;
 declare const index_IssueNewTokenRequest: typeof IssueNewTokenRequest;
+type index_IssueNewTokenResponse = IssueNewTokenResponse;
 type index_LinkContractRequest = LinkContractRequest;
-type index_LinkedTokenData = LinkedTokenData;
-type index_LinkedTokenResponse = LinkedTokenResponse;
-declare const index_MintTokenRequest: typeof MintTokenRequest;
+type index_LinkContractResponse = LinkContractResponse;
+type index_MintTokenRequest = MintTokenRequest;
+declare const index_MintTokenResponse: typeof MintTokenResponse;
+declare const index_NativeBalanceData: typeof NativeBalanceData;
+type index_NativeBalanceResponse = NativeBalanceResponse;
 type index_NotFoundError = NotFoundError;
 declare const index_NotFoundError: typeof NotFoundError;
-declare const index_PaginatedResponse: typeof PaginatedResponse;
-declare const index_ReadFunctionRequest: typeof ReadFunctionRequest;
-type index_SuccessResponse = SuccessResponse;
-type index_TemporalWorkflowStatusData = TemporalWorkflowStatusData;
-declare const index_WriteFunctionRequest: typeof WriteFunctionRequest;
+type index_Pagination = Pagination;
+declare const index_ProfileResponse: typeof ProfileResponse;
+declare const index_ProfilesResponse: typeof ProfilesResponse;
+type index_ReadCallFunctionRequest = ReadCallFunctionRequest;
+type index_ReadCallFunctionRequestNetwork = ReadCallFunctionRequestNetwork;
+declare const index_ReadCallFunctionResponse: typeof ReadCallFunctionResponse;
+type index_ServiceUnavailableError = ServiceUnavailableError;
+declare const index_ServiceUnavailableError: typeof ServiceUnavailableError;
+type index_TemporalWorkflowError = TemporalWorkflowError;
+declare const index_TemporalWorkflowStatusData: typeof TemporalWorkflowStatusData;
+declare const index_TokenData: typeof TokenData;
+declare const index_TokenResponse: typeof TokenResponse;
+declare const index_TokensResponse: typeof TokensResponse;
+declare const index_TransactionData: typeof TransactionData;
+declare const index_TransactionReceiptResponse: typeof TransactionReceiptResponse;
+type index_TransactionsByProfileResponse = TransactionsByProfileResponse;
+type index_TransactionsResponse = TransactionsResponse;
+type index_UnauthorizedError = UnauthorizedError;
+declare const index_UnauthorizedError: typeof UnauthorizedError;
+declare const index_UnlinkTokenResponse: typeof UnlinkTokenResponse;
+type index_UnprocessableEntityError = UnprocessableEntityError;
+declare const index_UnprocessableEntityError: typeof UnprocessableEntityError;
+declare const index_WalletData: typeof WalletData;
+type index_WalletResponse = WalletResponse;
+type index_WalletsResponse = WalletsResponse;
+declare const index_WithdrawResponse: typeof WithdrawResponse;
+type index_WorkflowResponse = WorkflowResponse;
+type index_WriteCallFunctionRequest = WriteCallFunctionRequest;
+type index_WriteCallFunctionRequestNetwork = WriteCallFunctionRequestNetwork;
+declare const index_WriteCallFunctionResponse: typeof WriteCallFunctionResponse;
 declare namespace index {
   export {
     index_AddContractAbiRequest as AddContractAbiRequest,
+    index_AddContractAbiResponse as AddContractAbiResponse,
+    index_AddressData as AddressData,
+    index_AddressesResponse as AddressesResponse,
+    index_AssetData as AssetData,
+    index_AssetsResponse as AssetsResponse,
+    index_BadGatewayError as BadGatewayError,
     index_BadRequestError as BadRequestError,
     index_BurnTokenRequest as BurnTokenRequest,
+    index_BurnTokenResponse as BurnTokenResponse,
+    index_CollectionData as CollectionData,
+    index_CollectionResponse as CollectionResponse,
+    index_CollectionTokenData as CollectionTokenData,
+    index_CollectionTokenDetailsResponse as CollectionTokenDetailsResponse,
+    index_CollectionTokensResponse as CollectionTokensResponse,
+    index_CollectionsResponse as CollectionsResponse,
+    index_ConflictError as ConflictError,
+    index_ContractAbiResponse as ContractAbiResponse,
+    index_ContractConstructorResponse as ContractConstructorResponse,
+    index_ContractFunctionsResponse as ContractFunctionsResponse,
+    index_ContractTemplateByIdResponse as ContractTemplateByIdResponse,
+    index_ContractTemplateData as ContractTemplateData,
+    index_ContractTemplateFunction as ContractTemplateFunction,
+    index_ContractTemplateResponse as ContractTemplateResponse,
+    index_ContractTemplatesResponse as ContractTemplatesResponse,
     index_CreateAddressRequest as CreateAddressRequest,
+    index_CreateAddressResponse as CreateAddressResponse,
     index_CreateCollectionRequest as CreateCollectionRequest,
-    index_CreateContractTemplateRequest as CreateContractTemplateRequest,
+    index_CreateContractRequest as CreateContractRequest,
     index_CreateProfileRequest as CreateProfileRequest,
     index_CreateWalletRequest as CreateWalletRequest,
-    index_CreateWithdrawalRequest as CreateWithdrawalRequest,
+    index_CreateWithdrawRequest as CreateWithdrawRequest,
     index_DeployContractRequest as DeployContractRequest,
+    index_DeployContractResponse as DeployContractResponse,
+    index_DeployedContractByAddressResponse as DeployedContractByAddressResponse,
+    index_DeployedContractByIdResponse as DeployedContractByIdResponse,
+    index_DeployedContractData as DeployedContractData,
+    index_DeployedContractResponse as DeployedContractResponse,
+    index_DeployedContractsResponse as DeployedContractsResponse,
     index_ErrorResponse as ErrorResponse,
     index_FetchContractAbiRequest as FetchContractAbiRequest,
+    index_FetchContractAbiResponse as FetchContractAbiResponse,
+    index_ForbiddenError as ForbiddenError,
+    index_GatewayTimeoutError as GatewayTimeoutError,
+    index_GetAddressForOrganizationRequest as GetAddressForOrganizationRequest,
+    index_GetAddressForProfileRequest as GetAddressForProfileRequest,
     index_GetAssetsRequest as GetAssetsRequest,
     index_GetCollectionTokensRequest as GetCollectionTokensRequest,
-    index_GetCollectionTokensRequestType as GetCollectionTokensRequestType,
     index_GetCollectionsRequest as GetCollectionsRequest,
-    index_GetContractTemplatesRequest as GetContractTemplatesRequest,
+    index_GetContractsRequest as GetContractsRequest,
+    index_GetDeployedContractAbiRequestNetwork as GetDeployedContractAbiRequestNetwork,
+    index_GetDeployedContractByAddressRequestNetwork as GetDeployedContractByAddressRequestNetwork,
     index_GetDeployedContractsRequest as GetDeployedContractsRequest,
     index_GetDeployedContractsRequestNetwork as GetDeployedContractsRequestNetwork,
-    index_GetOrganizationAddressesRequest as GetOrganizationAddressesRequest,
-    index_GetOrganizationTransactionsRequest as GetOrganizationTransactionsRequest,
-    index_GetOrganizationWalletsRequest as GetOrganizationWalletsRequest,
-    index_GetProfileAddressesRequest as GetProfileAddressesRequest,
-    index_GetProfileTransactionsRequest as GetProfileTransactionsRequest,
-    index_GetProfileWalletsRequest as GetProfileWalletsRequest,
+    index_GetLinkedTokenResponse as GetLinkedTokenResponse,
+    index_GetNativeBalanceRequest as GetNativeBalanceRequest,
+    index_GetNativeBalanceRequestNetwork as GetNativeBalanceRequestNetwork,
     index_GetProfilesRequest as GetProfilesRequest,
-    index_GetTemplateFunctionsRequest as GetTemplateFunctionsRequest,
     index_GetTokensRequest as GetTokensRequest,
+    index_GetTransactionReceiptRequestNetwork as GetTransactionReceiptRequestNetwork,
     index_GetTransactionsByAddressRequest as GetTransactionsByAddressRequest,
-    index_GetTransactionsByWalletRequest as GetTransactionsByWalletRequest,
+    index_GetTransactionsByMiniWalletRequest as GetTransactionsByMiniWalletRequest,
+    index_GetTransactionsByOrganizationRequest as GetTransactionsByOrganizationRequest,
+    index_GetTransactionsByProfileRequest as GetTransactionsByProfileRequest,
+    index_GetWalletsByProfileRequest as GetWalletsByProfileRequest,
+    index_GetWalletsForOrganizationRequest as GetWalletsForOrganizationRequest,
+    index_InternalServerError as InternalServerError,
     index_IssueNewTokenRequest as IssueNewTokenRequest,
+    index_IssueNewTokenResponse as IssueNewTokenResponse,
     index_LinkContractRequest as LinkContractRequest,
-    index_LinkedTokenData as LinkedTokenData,
-    index_LinkedTokenResponse as LinkedTokenResponse,
+    index_LinkContractResponse as LinkContractResponse,
     index_MintTokenRequest as MintTokenRequest,
+    index_MintTokenResponse as MintTokenResponse,
+    index_NativeBalanceData as NativeBalanceData,
+    index_NativeBalanceResponse as NativeBalanceResponse,
     index_NotFoundError as NotFoundError,
-    index_PaginatedResponse as PaginatedResponse,
-    index_ReadFunctionRequest as ReadFunctionRequest,
-    index_SuccessResponse as SuccessResponse,
+    index_Pagination as Pagination,
+    index_ProfileResponse as ProfileResponse,
+    index_ProfilesResponse as ProfilesResponse,
+    index_ReadCallFunctionRequest as ReadCallFunctionRequest,
+    index_ReadCallFunctionRequestNetwork as ReadCallFunctionRequestNetwork,
+    index_ReadCallFunctionResponse as ReadCallFunctionResponse,
+    index_ServiceUnavailableError as ServiceUnavailableError,
+    index_TemporalWorkflowError as TemporalWorkflowError,
     index_TemporalWorkflowStatusData as TemporalWorkflowStatusData,
-    index_WriteFunctionRequest as WriteFunctionRequest,
-    index$7 as addresses,
-    index$1 as assets,
-    index$3 as contractInteractions,
-    index$4 as contractTemplates,
-    index$b as deployedContracts,
-    index$9 as profiles,
+    index_TokenData as TokenData,
+    index_TokenResponse as TokenResponse,
+    index_TokensResponse as TokensResponse,
+    index_TransactionData as TransactionData,
+    index_TransactionReceiptResponse as TransactionReceiptResponse,
+    index_TransactionsByProfileResponse as TransactionsByProfileResponse,
+    index_TransactionsResponse as TransactionsResponse,
+    index_UnauthorizedError as UnauthorizedError,
+    index_UnlinkTokenResponse as UnlinkTokenResponse,
+    index_UnprocessableEntityError as UnprocessableEntityError,
+    index_WalletData as WalletData,
+    index_WalletResponse as WalletResponse,
+    index_WalletsResponse as WalletsResponse,
+    index_WithdrawResponse as WithdrawResponse,
+    index_WorkflowResponse as WorkflowResponse,
+    index_WriteCallFunctionRequest as WriteCallFunctionRequest,
+    index_WriteCallFunctionRequestNetwork as WriteCallFunctionRequestNetwork,
+    index_WriteCallFunctionResponse as WriteCallFunctionResponse,
+    index$4 as addresses,
+    index$7 as contractInteractions,
+    index$9 as contractTemplates,
+    index$8 as deployedContracts,
+    index$b as portfolio,
+    index$6 as profiles,
     index$2 as temporal,
     index$a as tokenization,
-    index$6 as transactions,
-    index$8 as wallets,
-    index$5 as withdrawals,
+    index$3 as transactions,
+    index$5 as wallets,
+    index$1 as withdrawals,
   };
 }
 
@@ -1287,18 +2246,22 @@ declare class Profiles {
     protected readonly _options: Profiles.Options;
     constructor(_options: Profiles.Options);
     /**
-     * Retrieve a paginated list of profiles
+     * Get list of profiles with pagination
      *
      * @param {OumlaSdkApi.GetProfilesRequest} request
      * @param {Profiles.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
      *     await client.profiles.getProfiles({
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getProfiles(request?: GetProfilesRequest, requestOptions?: Profiles.RequestOptions): HttpResponsePromise<PaginatedResponse>;
+    getProfiles(request?: GetProfilesRequest, requestOptions?: Profiles.RequestOptions): HttpResponsePromise<ProfilesResponse>;
     private __getProfiles;
     /**
      * Create a new user profile
@@ -1307,14 +2270,19 @@ declare class Profiles {
      * @param {Profiles.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
      *     await client.profiles.createProfile({
-     *         reference: "reference",
+     *         reference: "user-123",
      *         type: "User"
      *     })
      */
-    createProfile(request: CreateProfileRequest, requestOptions?: Profiles.RequestOptions): HttpResponsePromise<SuccessResponse>;
+    createProfile(request: CreateProfileRequest, requestOptions?: Profiles.RequestOptions): HttpResponsePromise<ProfileResponse>;
     private __createProfile;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
@@ -1356,48 +2324,64 @@ declare class Wallets {
     protected readonly _options: Wallets.Options;
     constructor(_options: Wallets.Options);
     /**
-     * Retrieve wallets for the organization
+     * Generate a new wallet for a profile
      *
-     * @param {OumlaSdkApi.GetOrganizationWalletsRequest} request
+     * @param {OumlaSdkApi.CreateWalletRequest} request
      * @param {Wallets.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.wallets.getOrganizationWallets({
-     *         skip: 1,
-     *         take: 1
+     *     await client.wallets.createWallet({
+     *         reference: "user-123",
+     *         network: "tBTC"
      *     })
      */
-    getOrganizationWallets(request?: GetOrganizationWalletsRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getOrganizationWallets;
+    createWallet(request: CreateWalletRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<WalletResponse>;
+    private __createWallet;
     /**
-     * Retrieve wallets for a specific profile
+     * Get wallets for a specific profile
      *
-     * @param {string} reference - Profile reference
-     * @param {OumlaSdkApi.GetProfileWalletsRequest} request
+     * @param {string} reference - Profile or organization reference identifier
+     * @param {OumlaSdkApi.GetWalletsByProfileRequest} request
      * @param {Wallets.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.wallets.getProfileWallets("reference", {
+     *     await client.wallets.getWalletsByProfile("reference", {
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getProfileWallets(reference: string, request?: GetProfileWalletsRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getProfileWallets;
+    getWalletsByProfile(reference: string, request?: GetWalletsByProfileRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<WalletsResponse>;
+    private __getWalletsByProfile;
     /**
-     * Generate a new wallet for a profile
+     * Get all wallets for the organization
      *
-     * @param {OumlaSdkApi.CreateWalletRequest} request
+     * @param {OumlaSdkApi.GetWalletsForOrganizationRequest} request
      * @param {Wallets.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.wallets.generateWallet({
-     *         reference: "reference",
-     *         network: "BTC"
+     *     await client.wallets.getWalletsForOrganization({
+     *         skip: 1,
+     *         take: 1
      *     })
      */
-    generateWallet(request: CreateWalletRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __generateWallet;
+    getWalletsForOrganization(request?: GetWalletsForOrganizationRequest, requestOptions?: Wallets.RequestOptions): HttpResponsePromise<WalletsResponse>;
+    private __getWalletsForOrganization;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
@@ -1438,64 +2422,83 @@ declare class Addresses {
     protected readonly _options: Addresses.Options;
     constructor(_options: Addresses.Options);
     /**
-     * Retrieve addresses for the organization
+     * Generate a new address for a profile
      *
-     * @param {OumlaSdkApi.GetOrganizationAddressesRequest} request
+     * @param {OumlaSdkApi.CreateAddressRequest} request
      * @param {Addresses.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.addresses.getOrganizationAddresses({
-     *         skip: 1,
-     *         take: 1
+     *     await client.addresses.createAddress({
+     *         reference: "user-123",
+     *         network: "tBTC",
+     *         clientShare: "clientShare"
      *     })
      */
-    getOrganizationAddresses(request?: GetOrganizationAddressesRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getOrganizationAddresses;
+    createAddress(request: CreateAddressRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<CreateAddressResponse>;
+    private __createAddress;
     /**
-     * Retrieve addresses for a specific profile
+     * Generate a wallet if not exists and create address
      *
-     * @param {string} reference - Profile reference
-     * @param {OumlaSdkApi.GetProfileAddressesRequest} request
+     * @param {OumlaSdkApi.CreateAddressRequest} request
      * @param {Addresses.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.addresses.getProfileAddresses("reference", {
-     *         skip: 1,
-     *         take: 1
+     *     await client.addresses.createAddressV2({
+     *         reference: "user-123",
+     *         network: "tBTC",
+     *         clientShare: "clientShare"
      *     })
      */
-    getProfileAddresses(reference: string, request?: GetProfileAddressesRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getProfileAddresses;
+    createAddressV2(request: CreateAddressRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<CreateAddressResponse>;
+    private __createAddressV2;
     /**
-     * Generate a new address for a profile
+     * Get all addresses for the organization
      *
-     * @param {OumlaSdkApi.CreateAddressRequest} request
+     * @param {OumlaSdkApi.GetAddressForOrganizationRequest} request
      * @param {Addresses.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.addresses.generateAddressV1({
-     *         reference: "reference",
-     *         network: "BTC",
-     *         clientShare: "clientShare"
+     *     await client.addresses.getAddressForOrganization({
+     *         skip: 1,
+     *         take: 1
      *     })
      */
-    generateAddressV1(request: CreateAddressRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __generateAddressV1;
+    getAddressForOrganization(request?: GetAddressForOrganizationRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<AddressesResponse>;
+    private __getAddressForOrganization;
     /**
-     * Generate a new address for a profile
+     * Get addresses for a specific profile
      *
-     * @param {OumlaSdkApi.CreateAddressRequest} request
+     * @param {string} reference - Profile or organization reference identifier
+     * @param {OumlaSdkApi.GetAddressForProfileRequest} request
      * @param {Addresses.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.addresses.generateAddressV2({
-     *         reference: "reference",
-     *         network: "BTC",
-     *         clientShare: "clientShare"
+     *     await client.addresses.getAddressForProfile("reference", {
+     *         skip: 1,
+     *         take: 1
      *     })
      */
-    generateAddressV2(request: CreateAddressRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __generateAddressV2;
+    getAddressForProfile(reference: string, request?: GetAddressForProfileRequest, requestOptions?: Addresses.RequestOptions): HttpResponsePromise<AddressesResponse>;
+    private __getAddressForProfile;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
@@ -1536,68 +2539,91 @@ declare class Transactions {
     protected readonly _options: Transactions.Options;
     constructor(_options: Transactions.Options);
     /**
-     * Retrieve transactions for a specific address
+     * Get transactions for a specific address
      *
      * @param {string} address - Blockchain address
      * @param {OumlaSdkApi.GetTransactionsByAddressRequest} request
      * @param {Transactions.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
      *     await client.transactions.getTransactionsByAddress("address", {
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getTransactionsByAddress(address: string, request?: GetTransactionsByAddressRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<PaginatedResponse>;
+    getTransactionsByAddress(address: string, request?: GetTransactionsByAddressRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<TransactionsResponse>;
     private __getTransactionsByAddress;
     /**
-     * Retrieve transactions for a specific wallet
+     * Get transactions for a specific wallet
      *
-     * @param {string} miniWalletId - Mini wallet ID
-     * @param {OumlaSdkApi.GetTransactionsByWalletRequest} request
+     * @param {string} miniWalletId - Mini wallet identifier
+     * @param {OumlaSdkApi.GetTransactionsByMiniWalletRequest} request
      * @param {Transactions.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.transactions.getTransactionsByWallet("miniWalletId", {
+     *     await client.transactions.getTransactionsByMiniWallet("miniWalletId", {
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getTransactionsByWallet(miniWalletId: string, request?: GetTransactionsByWalletRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getTransactionsByWallet;
+    getTransactionsByMiniWallet(miniWalletId: string, request?: GetTransactionsByMiniWalletRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<TransactionsResponse>;
+    private __getTransactionsByMiniWallet;
     /**
-     * Retrieve transactions for the organization
+     * Get all transactions for the organization
      *
-     * @param {OumlaSdkApi.GetOrganizationTransactionsRequest} request
+     * @param {OumlaSdkApi.GetTransactionsByOrganizationRequest} request
      * @param {Transactions.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.transactions.getOrganizationTransactions({
+     *     await client.transactions.getTransactionsByOrganization({
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getOrganizationTransactions(request?: GetOrganizationTransactionsRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getOrganizationTransactions;
+    getTransactionsByOrganization(request?: GetTransactionsByOrganizationRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<TransactionsResponse>;
+    private __getTransactionsByOrganization;
     /**
-     * Retrieve transactions for a specific profile
+     * Get transactions for a specific profile
      *
-     * @param {string} reference - Profile reference
-     * @param {OumlaSdkApi.GetProfileTransactionsRequest} request
+     * @param {string} reference - Profile or organization reference identifier
+     * @param {OumlaSdkApi.GetTransactionsByProfileRequest} request
      * @param {Transactions.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
      * @example
-     *     await client.transactions.getProfileTransactions("reference", {
+     *     await client.transactions.getTransactionsByProfile("reference", {
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getProfileTransactions(reference: string, request?: GetProfileTransactionsRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getProfileTransactions;
+    getTransactionsByProfile(reference: string, request?: GetTransactionsByProfileRequest, requestOptions?: Transactions.RequestOptions): HttpResponsePromise<TransactionsByProfileResponse>;
+    private __getTransactionsByProfile;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace Withdrawals {
+declare namespace Portfolio {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -1628,32 +2654,61 @@ declare namespace Withdrawals {
     }
 }
 /**
- * Withdrawal operations
+ * Portfolio management and tracking
  */
-declare class Withdrawals {
-    protected readonly _options: Withdrawals.Options;
-    constructor(_options: Withdrawals.Options);
+declare class Portfolio {
+    protected readonly _options: Portfolio.Options;
+    constructor(_options: Portfolio.Options);
     /**
-     * Create a new withdrawal request
+     * Get assets for address, wallet, or contract
      *
-     * @param {OumlaSdkApi.CreateWithdrawalRequest} request
-     * @param {Withdrawals.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.GetAssetsRequest} request
+     * @param {Portfolio.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.withdrawals.createWithdrawal({
-     *         to: "to",
-     *         amount: "amount",
-     *         from: ["from"],
-     *         network: "BTC",
-     *         clientShare: "clientShare"
+     *     await client.portfolio.getAssets({
+     *         address: "address",
+     *         walletId: "walletId",
+     *         contractAddress: "contractAddress",
+     *         tokenizationId: "tokenizationId",
+     *         skip: 1,
+     *         take: 1
+     *     })
+     */
+    getAssets(request?: GetAssetsRequest, requestOptions?: Portfolio.RequestOptions): HttpResponsePromise<AssetsResponse>;
+    private __getAssets;
+    /**
+     * Get native balance for network, address, or wallet
+     *
+     * @param {OumlaSdkApi.GetNativeBalanceRequest} request
+     * @param {Portfolio.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.portfolio.getNativeBalance({
+     *         network: "tBTC",
+     *         address: "address",
+     *         walletId: "walletId",
+     *         skip: 1,
+     *         take: 1
      *     })
      */
-    createWithdrawal(request: CreateWithdrawalRequest, requestOptions?: Withdrawals.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __createWithdrawal;
+    getNativeBalance(request: GetNativeBalanceRequest, requestOptions?: Portfolio.RequestOptions): HttpResponsePromise<NativeBalanceResponse>;
+    private __getNativeBalance;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace ContractTemplates {
+declare namespace Temporal {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -1684,110 +2739,32 @@ declare namespace ContractTemplates {
     }
 }
 /**
- * Smart contract template management
+ * Temporal workflow operations
  */
-declare class ContractTemplates {
-    protected readonly _options: ContractTemplates.Options;
-    constructor(_options: ContractTemplates.Options);
-    /**
-     * Retrieve a paginated list of contract templates
-     *
-     * @param {OumlaSdkApi.GetContractTemplatesRequest} request
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.contractTemplates.getContractTemplates({
-     *         skip: 1,
-     *         take: 1
-     *     })
-     */
-    getContractTemplates(request?: GetContractTemplatesRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getContractTemplates;
-    /**
-     * Create a new contract template
-     *
-     * @param {OumlaSdkApi.CreateContractTemplateRequest} request
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.contractTemplates.createContractTemplate({
-     *         name: "name",
-     *         description: "description",
-     *         abi: [{
-     *                 "key": "value"
-     *             }],
-     *         bytecode: "bytecode"
-     *     })
-     */
-    createContractTemplate(request: CreateContractTemplateRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __createContractTemplate;
-    /**
-     * Retrieve a specific contract template
-     *
-     * @param {string} templateId - Contract template ID
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.contractTemplates.getContractTemplate("templateId")
-     */
-    getContractTemplate(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getContractTemplate;
-    /**
-     * Delete a contract template
-     *
-     * @param {string} templateId - Contract template ID
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.contractTemplates.deleteContractTemplate("templateId")
-     */
-    deleteContractTemplate(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __deleteContractTemplate;
-    /**
-     * Retrieve constructor information for a contract template
-     *
-     * @param {string} templateId - Contract template ID
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.contractTemplates.getContractConstructor("templateId")
-     */
-    getContractConstructor(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getContractConstructor;
+declare class Temporal {
+    protected readonly _options: Temporal.Options;
+    constructor(_options: Temporal.Options);
     /**
-     * Retrieve function information for a contract template
-     *
-     * @param {string} templateId - Contract template ID
-     * @param {OumlaSdkApi.GetTemplateFunctionsRequest} request
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     * Get status and result of a Temporal workflow
      *
-     * @example
-     *     await client.contractTemplates.getTemplateFunctions("templateId", {
-     *         functionSignature: "functionSignature"
-     *     })
-     */
-    getTemplateFunctions(templateId: string, request?: GetTemplateFunctionsRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getTemplateFunctions;
-    /**
-     * Deploy a contract from a template
+     * @param {string} workflowId - Temporal workflow ID
+     * @param {Temporal.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @param {string} templateId - Contract template ID
-     * @param {OumlaSdkApi.DeployContractRequest} request
-     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.contractTemplates.deployContract("templateId", {
-     *         network: "network",
-     *         addressId: "addressId",
-     *         clientShare: "clientShare"
-     *     })
+     *     await client.temporal.getWorkflowStatus("workflowId")
      */
-    deployContract(templateId: string, request: DeployContractRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __deployContract;
+    getWorkflowStatus(workflowId: string, requestOptions?: Temporal.RequestOptions): HttpResponsePromise<TemporalWorkflowStatusData>;
+    private __getWorkflowStatus;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace DeployedContracts {
+declare namespace Tokenization {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -1818,87 +2795,295 @@ declare namespace DeployedContracts {
     }
 }
 /**
- * Deployed contract management
+ * Token creation, minting, and management
  */
-declare class DeployedContracts {
-    protected readonly _options: DeployedContracts.Options;
-    constructor(_options: DeployedContracts.Options);
+declare class Tokenization {
+    protected readonly _options: Tokenization.Options;
+    constructor(_options: Tokenization.Options);
     /**
-     * Retrieve a paginated list of deployed contracts
+     * Get list of tokens with pagination
      *
-     * @param {OumlaSdkApi.GetDeployedContractsRequest} request
-     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.GetTokensRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.deployedContracts.getDeployedContracts({
+     *     await client.tokenization.getTokens({
      *         skip: 1,
-     *         take: 1,
-     *         contractAddress: "contractAddress",
-     *         network: "BTC",
-     *         contractTemplateId: "contractTemplateId"
+     *         take: 1
      *     })
      */
-    getDeployedContracts(request?: GetDeployedContractsRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getDeployedContracts;
+    getTokens(request?: GetTokensRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<TokensResponse>;
+    private __getTokens;
     /**
-     * Retrieve a specific deployed contract
+     * Issue a new token
      *
-     * @param {string} contractId - Deployed contract ID
-     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.IssueNewTokenRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
      *
      * @example
-     *     await client.deployedContracts.getDeployedContract("contractId")
+     *     await client.tokenization.issueNewToken({
+     *         network: "tBTC",
+     *         addressId: "addressId",
+     *         clientShare: "clientShare",
+     *         createParams: {
+     *             "key": "value"
+     *         },
+     *         deploymentId: "deploymentId"
+     *     })
      */
-    getDeployedContract(contractId: string, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getDeployedContract;
+    issueNewToken(request: IssueNewTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<TokenData>;
+    private __issueNewToken;
     /**
-     * Retrieve a deployed contract by network and address
+     * Link an existing contract
      *
-     * @param {string} network - Blockchain network
-     * @param {string} contractAddress - Contract address
-     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.LinkContractRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.deployedContracts.getDeployedContractByAddress("network", "contractAddress")
+     *     await client.tokenization.linkContract({
+     *         contractAddress: "contractAddress"
+     *     })
      */
-    getDeployedContractByAddress(network: string, contractAddress: string, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getDeployedContractByAddress;
+    linkContract(request: LinkContractRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<LinkContractResponse>;
+    private __linkContract;
     /**
-     * Fetch ABI for a deployed contract
+     * Get linked token by ID
      *
-     * @param {OumlaSdkApi.FetchContractAbiRequest} request
-     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {string} id - Token ID
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.deployedContracts.fetchContractAbi({
-     *         network: "network",
-     *         contractAddress: "contractAddress"
+     *     await client.tokenization.getLinkedToken("id")
+     */
+    getLinkedToken(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<GetLinkedTokenResponse>;
+    private __getLinkedToken;
+    /**
+     * Unlink a token
+     *
+     * @param {string} id - Token ID
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.unlinkToken("id")
+     */
+    unlinkToken(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<UnlinkTokenResponse>;
+    private __unlinkToken;
+    /**
+     * Get list of collections with pagination
+     *
+     * @param {OumlaSdkApi.GetCollectionsRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.getCollections({
+     *         skip: 1,
+     *         take: 1
      *     })
      */
-    fetchContractAbi(request: FetchContractAbiRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __fetchContractAbi;
+    getCollections(request?: GetCollectionsRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<CollectionsResponse>;
+    private __getCollections;
     /**
-     * Add ABI for a deployed contract
+     * Create a new collection - workflow started
      *
-     * @param {OumlaSdkApi.AddContractAbiRequest} request
-     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.CreateCollectionRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
      *
      * @example
-     *     await client.deployedContracts.addContractAbi({
+     *     await client.tokenization.createCollection({
      *         network: "network",
-     *         contractAddress: "contractAddress",
-     *         name: "name",
-     *         abi: [{
-     *                 "key": "value"
-     *             }]
+     *         addressId: "addressId",
+     *         clientShare: "clientShare",
+     *         createParams: {
+     *             "key": "value"
+     *         },
+     *         deploymentId: "deploymentId"
      *     })
      */
-    addContractAbi(request: AddContractAbiRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __addContractAbi;
+    createCollection(request: CreateCollectionRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<WorkflowResponse>;
+    private __createCollection;
+    /**
+     * Get collection details by ID
+     *
+     * @param {string} id - Collection ID
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.getCollectionById("id")
+     */
+    getCollectionById(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<CollectionResponse>;
+    private __getCollectionById;
+    /**
+     * Delete a collection by ID
+     *
+     * @param {string} id - Collection ID
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.deleteCollection("id")
+     */
+    deleteCollection(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<Record<string, unknown>>;
+    private __deleteCollection;
+    /**
+     * Get token details from a collection
+     *
+     * @param {string} id - Collection ID
+     * @param {string} tokenId - Token ID
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.getCollectionTokenDetails("id", "tokenId")
+     */
+    getCollectionTokenDetails(id: string, tokenId: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<CollectionTokenDetailsResponse>;
+    private __getCollectionTokenDetails;
+    /**
+     * Mint new tokens in a collection
+     *
+     * @param {string} id - Collection ID
+     * @param {OumlaSdkApi.MintTokenRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
+     *
+     * @example
+     *     await client.tokenization.mintToken("id", {
+     *         addressId: "addressId",
+     *         clientShare: "clientShare",
+     *         to: "to"
+     *     })
+     */
+    mintToken(id: string, request: MintTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<MintTokenResponse>;
+    private __mintToken;
+    /**
+     * Burn tokens from a collection
+     *
+     * @param {string} id - Collection ID
+     * @param {OumlaSdkApi.BurnTokenRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
+     *
+     * @example
+     *     await client.tokenization.burnToken("id", {
+     *         addressId: "addressId",
+     *         clientShare: "clientShare",
+     *         tokenId: "tokenId"
+     *     })
+     */
+    burnToken(id: string, request: BurnTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<BurnTokenResponse>;
+    private __burnToken;
+    /**
+     * Get tokens from a collection by ID or type
+     *
+     * @param {OumlaSdkApi.GetCollectionTokensRequest} request
+     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.tokenization.getCollectionTokens({
+     *         id: "id",
+     *         type: "type",
+     *         skip: 1,
+     *         take: 1
+     *     })
+     */
+    getCollectionTokens(request?: GetCollectionTokensRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<CollectionTokensResponse>;
+    private __getCollectionTokens;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace ContractInteractions {
+declare namespace ContractTemplates {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -1929,81 +3114,158 @@ declare namespace ContractInteractions {
     }
 }
 /**
- * Smart contract interaction operations
+ * Smart contract template management
  */
-declare class ContractInteractions {
-    protected readonly _options: ContractInteractions.Options;
-    constructor(_options: ContractInteractions.Options);
+declare class ContractTemplates {
+    protected readonly _options: ContractTemplates.Options;
+    constructor(_options: ContractTemplates.Options);
     /**
-     * Retrieve available functions for a deployed contract
+     * Get list of contract templates with pagination
      *
-     * @param {string} network - Blockchain network
-     * @param {string} contractAddress - Contract address
-     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.GetContractsRequest} request
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.contractInteractions.getContractFunctions("network", "contractAddress")
+     *     await client.contractTemplates.getContracts({
+     *         skip: 1,
+     *         take: 1
+     *     })
      */
-    getContractFunctions(network: string, contractAddress: string, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getContractFunctions;
+    getContracts(request?: GetContractsRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<ContractTemplatesResponse>;
+    private __getContracts;
     /**
-     * Call a read function on a deployed contract
+     * Create a new contract template
      *
-     * @param {string} network - Blockchain network
-     * @param {string} contractAddress - Contract address
-     * @param {OumlaSdkApi.ReadFunctionRequest} request
-     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.CreateContractRequest} request
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
      *
      * @example
-     *     await client.contractInteractions.callReadFunction("network", "contractAddress", {
-     *         abiFunction: {
-     *             name: "name",
-     *             inputs: [{}],
-     *             outputs: [{}],
-     *             type: "type"
-     *         }
+     *     await client.contractTemplates.createContract({
+     *         name: "name",
+     *         description: "description",
+     *         bytecode: "bytecode",
+     *         abi: [{
+     *                 "key": "value"
+     *             }]
      *     })
      */
-    callReadFunction(network: string, contractAddress: string, request: ReadFunctionRequest, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __callReadFunction;
+    createContract(request: CreateContractRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<ContractTemplateResponse>;
+    private __createContract;
     /**
-     * Call a write function on a deployed contract
+     * Get contract template details by ID
      *
-     * @param {string} network - Blockchain network
-     * @param {string} contractAddress - Contract address
-     * @param {OumlaSdkApi.WriteFunctionRequest} request
-     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {string} templateId - Contract template ID
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.contractTemplates.getContractById("templateId")
+     */
+    getContractById(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<ContractTemplateByIdResponse>;
+    private __getContractById;
+    /**
+     * Delete a contract template by ID
+     *
+     * @param {string} templateId - Contract template ID
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.contractTemplates.deleteContract("templateId")
+     */
+    deleteContract(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<Record<string, unknown>>;
+    private __deleteContract;
+    /**
+     * Get contract constructor by template ID
+     *
+     * @param {string} templateId - Contract template ID
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.contractTemplates.getContractConstructorById("templateId")
+     */
+    getContractConstructorById(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<ContractConstructorResponse>;
+    private __getContractConstructorById;
+    /**
+     * Get contract functions by template ID
+     *
+     * @param {string} templateId - Contract template ID
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.contractInteractions.callWriteFunction("network", "contractAddress", {
-     *         addressId: "addressId",
-     *         clientShare: "clientShare",
-     *         abiFunction: {
-     *             name: "name",
-     *             inputs: [{}],
-     *             outputs: [{}],
-     *             type: "type"
-     *         }
-     *     })
+     *     await client.contractTemplates.getContractFunctionById("templateId")
      */
-    callWriteFunction(network: string, contractAddress: string, request: WriteFunctionRequest, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __callWriteFunction;
+    getContractFunctionById(templateId: string, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<ContractFunctionsResponse>;
+    private __getContractFunctionById;
     /**
-     * Retrieve transaction receipt for a specific transaction
+     * Deploy a contract from template
      *
-     * @param {string} network - Blockchain network
-     * @param {string} txId - Transaction ID
-     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {string} templateId - Contract template ID
+     * @param {OumlaSdkApi.DeployContractRequest} request
+     * @param {ContractTemplates.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
      *
      * @example
-     *     await client.contractInteractions.getTransactionReceipt("network", "txId")
+     *     await client.contractTemplates.deployContract("templateId", {
+     *         network: "network",
+     *         addressId: "addressId",
+     *         clientShare: "clientShare"
+     *     })
      */
-    getTransactionReceipt(network: string, txId: string, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getTransactionReceipt;
+    deployContract(templateId: string, request: DeployContractRequest, requestOptions?: ContractTemplates.RequestOptions): HttpResponsePromise<DeployContractResponse>;
+    private __deployContract;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace Tokenization {
+declare namespace DeployedContracts {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -2034,196 +3296,116 @@ declare namespace Tokenization {
     }
 }
 /**
- * Token creation, minting, and management
+ * Deployed contract management
  */
-declare class Tokenization {
-    protected readonly _options: Tokenization.Options;
-    constructor(_options: Tokenization.Options);
-    /**
-     * Retrieve a paginated list of tokens
-     *
-     * @param {OumlaSdkApi.GetTokensRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.tokenization.getTokens({
-     *         skip: 1,
-     *         take: 1
-     *     })
-     */
-    getTokens(request?: GetTokensRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getTokens;
-    /**
-     * Issue a new token using a contract template
-     *
-     * @param {OumlaSdkApi.IssueNewTokenRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.tokenization.issueNewToken({
-     *         addressId: "addressId",
-     *         clientShare: "clientShare",
-     *         deploymentId: "deploymentId",
-     *         createParams: {
-     *             initializeParams: [{
-     *                     name: "name",
-     *                     type: "type",
-     *                     value: "value"
-     *                 }]
-     *         }
-     *     })
-     */
-    issueNewToken(request: IssueNewTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __issueNewToken;
+declare class DeployedContracts {
+    protected readonly _options: DeployedContracts.Options;
+    constructor(_options: DeployedContracts.Options);
     /**
-     * Link an existing contract to the platform
-     *
-     * @param {OumlaSdkApi.LinkContractRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * Get list of deployed contracts with pagination
      *
-     * @example
-     *     await client.tokenization.linkContract({
-     *         contractAddress: "contractAddress"
-     *     })
-     */
-    linkContract(request: LinkContractRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __linkContract;
-    /**
-     * Retrieve a paginated list of collections
+     * @param {OumlaSdkApi.GetDeployedContractsRequest} request
+     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @param {OumlaSdkApi.GetCollectionsRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.tokenization.getCollections({
+     *     await client.deployedContracts.getDeployedContracts({
+     *         contractAddress: "contractAddress",
+     *         network: "tBTC",
+     *         contractTemplateId: "contractTemplateId",
      *         skip: 1,
      *         take: 1
      *     })
      */
-    getCollections(request?: GetCollectionsRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<PaginatedResponse>;
-    private __getCollections;
+    getDeployedContracts(request?: GetDeployedContractsRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<DeployedContractsResponse>;
+    private __getDeployedContracts;
     /**
-     * Create a new token collection
-     *
-     * @param {OumlaSdkApi.CreateCollectionRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * Get deployed contract details by ID
      *
-     * @example
-     *     await client.tokenization.createCollection({
-     *         type: "NON_FUNGIBLE_TOKEN",
-     *         addressId: "addressId",
-     *         clientShare: "clientShare",
-     *         createParams: {
-     *             initializeParams: [{
-     *                     name: "name",
-     *                     type: "type",
-     *                     value: "value"
-     *                 }]
-     *         }
-     *     })
-     */
-    createCollection(request: CreateCollectionRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __createCollection;
-    /**
-     * Retrieve a specific collection
+     * @param {string} contractId - Deployed contract ID
+     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @param {string} id - Collection ID
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.tokenization.getCollection("id")
+     *     await client.deployedContracts.getDeployedContractById("contractId")
      */
-    getCollection(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getCollection;
+    getDeployedContractById(contractId: string, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<DeployedContractByIdResponse>;
+    private __getDeployedContractById;
     /**
-     * Delete a collection
+     * Get deployed contract by address and network
      *
-     * @param {string} id - Collection ID
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.tokenization.deleteCollection("id")
-     */
-    deleteCollection(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __deleteCollection;
-    /**
-     * Retrieve details for a specific token in a collection
+     * @param {string} contractAddress - Contract address
+     * @param {OumlaSdkApi.GetDeployedContractByAddressRequestNetwork} network - Network
+     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @param {string} id - Collection ID
-     * @param {string} tokenId - Token ID
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.tokenization.getCollectionTokenDetails("id", "tokenId")
+     *     await client.deployedContracts.getDeployedContractByAddress("contractAddress", "tBTC")
      */
-    getCollectionTokenDetails(id: string, tokenId: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getCollectionTokenDetails;
+    getDeployedContractByAddress(contractAddress: string, network: GetDeployedContractByAddressRequestNetwork, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<DeployedContractByAddressResponse>;
+    private __getDeployedContractByAddress;
     /**
-     * Mint a new token in a collection
-     *
-     * @param {string} id - Collection ID
-     * @param {OumlaSdkApi.MintTokenRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * Fetch contract ABI from blockchain
      *
-     * @example
-     *     await client.tokenization.mintToken("id", {
-     *         addressId: "addressId",
-     *         clientShare: "clientShare",
-     *         to: "to",
-     *         tokenId: "tokenId"
-     *     })
-     */
-    mintToken(id: string, request: MintTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __mintToken;
-    /**
-     * Burn a token
+     * @param {OumlaSdkApi.FetchContractAbiRequest} request
+     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @param {string} id - Collection ID
-     * @param {OumlaSdkApi.BurnTokenRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.tokenization.burnToken("id", {
-     *         addressId: "addressId",
-     *         clientShare: "clientShare",
-     *         tokenId: "tokenId"
+     *     await client.deployedContracts.fetchContractAbi({
+     *         contractAddress: "contractAddress",
+     *         network: "network"
      *     })
      */
-    burnToken(id: string, request: BurnTokenRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __burnToken;
+    fetchContractAbi(request: FetchContractAbiRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<FetchContractAbiResponse>;
+    private __fetchContractAbi;
     /**
-     * Retrieve collection tokens (mints or burns) filtered by collection ID and type
+     * Add ABI for a deployed contract
      *
-     * @param {OumlaSdkApi.GetCollectionTokensRequest} request
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.AddContractAbiRequest} request
+     * @param {DeployedContracts.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
      * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.tokenization.getCollectionTokens({
-     *         id: "id",
-     *         type: "MINT",
-     *         skip: 1,
-     *         take: 1
+     *     await client.deployedContracts.addContractAbi({
+     *         contractAddress: "contractAddress",
+     *         network: "network",
+     *         name: "name",
+     *         abi: [{
+     *                 "key": "value"
+     *             }]
      *     })
      */
-    getCollectionTokens(request?: GetCollectionTokensRequest, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getCollectionTokens;
-    /**
-     * Unlink a token from the platform
-     *
-     * @param {string} id - Token ID
-     * @param {Tokenization.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @example
-     *     await client.tokenization.unlinkToken("id")
-     */
-    unlinkToken(id: string, requestOptions?: Tokenization.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __unlinkToken;
+    addContractAbi(request: AddContractAbiRequest, requestOptions?: DeployedContracts.RequestOptions): HttpResponsePromise<AddContractAbiResponse>;
+    private __addContractAbi;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace Temporal {
+declare namespace ContractInteractions {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -2254,28 +3436,103 @@ declare namespace Temporal {
     }
 }
 /**
- * Temporal workflow operations
+ * Smart contract interaction operations
  */
-declare class Temporal {
-    protected readonly _options: Temporal.Options;
-    constructor(_options: Temporal.Options);
+declare class ContractInteractions {
+    protected readonly _options: ContractInteractions.Options;
+    constructor(_options: ContractInteractions.Options);
     /**
-     * Get workflow status and result
+     * Get ABI functions for a deployed contract
      *
-     * @param {string} workflowId - Temporal workflow ID
-     * @param {Temporal.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.GetDeployedContractAbiRequestNetwork} network - Network
+     * @param {string} contractAddress - Contract address
+     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.contractInteractions.getDeployedContractAbi("tBTC", "contractAddress")
+     */
+    getDeployedContractAbi(network: GetDeployedContractAbiRequestNetwork, contractAddress: string, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<ContractAbiResponse>;
+    private __getDeployedContractAbi;
+    /**
+     * Call a read-only contract function
      *
+     * @param {OumlaSdkApi.ReadCallFunctionRequestNetwork} network - Network
+     * @param {string} contractAddress - Contract address
+     * @param {OumlaSdkApi.ReadCallFunctionRequest} request
+     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     *
+     * @example
+     *     await client.contractInteractions.readCallFunction("tBTC", "contractAddress", {
+     *         abiFunction: {
+     *             "key": "value"
+     *         }
+     *     })
+     */
+    readCallFunction(network: ReadCallFunctionRequestNetwork, contractAddress: string, request: ReadCallFunctionRequest, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<ReadCallFunctionResponse>;
+    private __readCallFunction;
+    /**
+     * Call a write contract function (transaction)
+     *
+     * @param {OumlaSdkApi.WriteCallFunctionRequestNetwork} network - Network
+     * @param {string} contractAddress - Contract address
+     * @param {OumlaSdkApi.WriteCallFunctionRequest} request
+     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
+     * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
+     *
+     * @example
+     *     await client.contractInteractions.writeCallFunction("tBTC", "contractAddress", {
+     *         addressId: "addressId",
+     *         clientShare: "clientShare",
+     *         abiFunction: {
+     *             "key": "value"
+     *         }
+     *     })
+     */
+    writeCallFunction(network: WriteCallFunctionRequestNetwork, contractAddress: string, request: WriteCallFunctionRequest, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<WriteCallFunctionResponse>;
+    private __writeCallFunction;
+    /**
+     * Get transaction receipt by network and transaction ID
+     *
+     * @param {OumlaSdkApi.GetTransactionReceiptRequestNetwork} network - Network
+     * @param {string} txId - Transaction ID
+     * @param {ContractInteractions.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
      * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
      *
      * @example
-     *     await client.temporal.getTemporalWorkflowStatus("workflowId")
+     *     await client.contractInteractions.getTransactionReceipt("tBTC", "txId")
      */
-    getTemporalWorkflowStatus(workflowId: string, requestOptions?: Temporal.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getTemporalWorkflowStatus;
+    getTransactionReceipt(network: GetTransactionReceiptRequestNetwork, txId: string, requestOptions?: ContractInteractions.RequestOptions): HttpResponsePromise<TransactionReceiptResponse>;
+    private __getTransactionReceipt;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
-declare namespace Assets {
+declare namespace Withdrawals {
     interface Options {
         environment?: Supplier<OumlaSdkApiEnvironment | string>;
         /** Specify a custom URL to connect the client to. */
@@ -2306,31 +3563,39 @@ declare namespace Assets {
     }
 }
 /**
- * Asset management and tracking
+ * Withdrawal operations
  */
-declare class Assets {
-    protected readonly _options: Assets.Options;
-    constructor(_options: Assets.Options);
+declare class Withdrawals {
+    protected readonly _options: Withdrawals.Options;
+    constructor(_options: Withdrawals.Options);
     /**
-     * Retrieve assets for the organization filtered by address, wallet ID, contract address, or tokenization ID
+     * Create a withdrawal transaction
      *
-     * @param {OumlaSdkApi.GetAssetsRequest} request
-     * @param {Assets.RequestOptions} requestOptions - Request-specific configuration.
+     * @param {OumlaSdkApi.CreateWithdrawRequest} request
+     * @param {Withdrawals.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link OumlaSdkApi.BadRequestError}
+     * @throws {@link OumlaSdkApi.UnauthorizedError}
+     * @throws {@link OumlaSdkApi.ForbiddenError}
      * @throws {@link OumlaSdkApi.NotFoundError}
+     * @throws {@link OumlaSdkApi.ConflictError}
+     * @throws {@link OumlaSdkApi.UnprocessableEntityError}
+     * @throws {@link OumlaSdkApi.InternalServerError}
+     * @throws {@link OumlaSdkApi.BadGatewayError}
+     * @throws {@link OumlaSdkApi.ServiceUnavailableError}
+     * @throws {@link OumlaSdkApi.GatewayTimeoutError}
      *
      * @example
-     *     await client.assets.getAssets({
-     *         address: "address",
-     *         walletId: "walletId",
-     *         contractAddress: "contractAddress",
-     *         tokenizationId: "tokenizationId",
-     *         skip: 1,
-     *         take: 1
+     *     await client.withdrawals.createWithdraw({
+     *         to: "to",
+     *         amount: "amount",
+     *         from: ["from"],
+     *         network: "tBTC",
+     *         clientShare: "clientShare"
      *     })
      */
-    getAssets(request?: GetAssetsRequest, requestOptions?: Assets.RequestOptions): HttpResponsePromise<SuccessResponse>;
-    private __getAssets;
+    createWithdraw(request: CreateWithdrawRequest, requestOptions?: Withdrawals.RequestOptions): HttpResponsePromise<WithdrawResponse>;
+    private __createWithdraw;
     protected _getAuthorizationHeader(): Promise<string | undefined>;
 }
 
@@ -2370,25 +3635,25 @@ declare class OumlaSdkApiClient {
     protected _wallets: Wallets | undefined;
     protected _addresses: Addresses | undefined;
     protected _transactions: Transactions | undefined;
-    protected _withdrawals: Withdrawals | undefined;
+    protected _portfolio: Portfolio | undefined;
+    protected _temporal: Temporal | undefined;
+    protected _tokenization: Tokenization | undefined;
     protected _contractTemplates: ContractTemplates | undefined;
     protected _deployedContracts: DeployedContracts | undefined;
     protected _contractInteractions: ContractInteractions | undefined;
-    protected _tokenization: Tokenization | undefined;
-    protected _temporal: Temporal | undefined;
-    protected _assets: Assets | undefined;
+    protected _withdrawals: Withdrawals | undefined;
     constructor(_options: OumlaSdkApiClient.Options);
     get profiles(): Profiles;
     get wallets(): Wallets;
     get addresses(): Addresses;
     get transactions(): Transactions;
-    get withdrawals(): Withdrawals;
+    get portfolio(): Portfolio;
+    get temporal(): Temporal;
+    get tokenization(): Tokenization;
     get contractTemplates(): ContractTemplates;
     get deployedContracts(): DeployedContracts;
     get contractInteractions(): ContractInteractions;
-    get tokenization(): Tokenization;
-    get temporal(): Temporal;
-    get assets(): Assets;
+    get withdrawals(): Withdrawals;
 }
 
 export { index as OumlaSdkApi, OumlaSdkApiClient, OumlaSdkApiEnvironment, OumlaSdkApiError, OumlaSdkApiTimeoutError };