@dfns/sdk 0.0.0-prealpha.9

package/codegen/Wallets/DelegatedWalletsClient.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedWalletsClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedWalletsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createWalletInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets', {
+            path: {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createWalletComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets', {
+            path: {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWallet(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletAssets(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/assets', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletNfts(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/nfts', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listWallets(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets', {
+            path: {},
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletHistory(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/history', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async transferAssetInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async transferAssetComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getTransfer(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers/:transferId', {
+            path: { walletId: request.walletId, transferId: request.transferId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listTransfers(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async broadcastTransactionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async broadcastTransactionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getTransaction(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions/:transactionId', {
+            path: {
+                walletId: request.walletId,
+                transactionId: request.transactionId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listTransactions(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async generateSignatureInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async generateSignatureComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getSignature(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures/:signatureId', {
+            path: { walletId: request.walletId, signatureId: request.signatureId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listSignatures(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedWalletsClient = DelegatedWalletsClient;

package/codegen/Wallets/WalletsClient.d.ts

@@ -0,0 +1,21 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class WalletsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createWallet(request: T.CreateWalletRequest): Promise<T.CreateWalletResponse>;
+    getWallet(request: T.GetWalletRequest): Promise<T.GetWalletResponse>;
+    getWalletAssets(request: T.GetWalletAssetsRequest): Promise<T.GetWalletAssetsResponse>;
+    getWalletNfts(request: T.GetWalletNftsRequest): Promise<T.GetWalletNftsResponse>;
+    listWallets(request: T.ListWalletsRequest): Promise<T.ListWalletsResponse>;
+    getWalletHistory(request: T.GetWalletHistoryRequest): Promise<T.GetWalletHistoryResponse>;
+    transferAsset(request: T.TransferAssetRequest): Promise<T.TransferAssetResponse>;
+    getTransfer(request: T.GetTransferRequest): Promise<T.GetTransferResponse>;
+    listTransfers(request: T.ListTransfersRequest): Promise<T.ListTransfersResponse>;
+    broadcastTransaction(request: T.BroadcastTransactionRequest): Promise<T.BroadcastTransactionResponse>;
+    getTransaction(request: T.GetTransactionRequest): Promise<T.GetTransactionResponse>;
+    listTransactions(request: T.ListTransactionsRequest): Promise<T.ListTransactionsResponse>;
+    generateSignature(request: T.GenerateSignatureRequest): Promise<T.GenerateSignatureResponse>;
+    getSignature(request: T.GetSignatureRequest): Promise<T.GetSignatureResponse>;
+    listSignatures(request: T.ListSignaturesRequest): Promise<T.ListSignaturesResponse>;
+}

package/codegen/Wallets/WalletsClient.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletsClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class WalletsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createWallet(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWallet(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletAssets(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/assets', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletNfts(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/nfts', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listWallets(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets', {
+            path: {},
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getWalletHistory(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/history', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async transferAsset(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getTransfer(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers/:transferId', {
+            path: { walletId: request.walletId, transferId: request.transferId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listTransfers(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transfers', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async broadcastTransaction(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getTransaction(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions/:transactionId', {
+            path: {
+                walletId: request.walletId,
+                transactionId: request.transactionId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listTransactions(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/transactions', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async generateSignature(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures', {
+            path: { walletId: request.walletId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getSignature(request) {
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures/:signatureId', {
+            path: { walletId: request.walletId, signatureId: request.signatureId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listSignatures(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/wallets/:walletId/signatures', {
+            path: { walletId: request.walletId },
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.WalletsClient = WalletsClient;

package/codegen/Wallets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedWalletsClient';
+export * from './types';
+export * from './WalletsClient';

package/codegen/Wallets/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DelegatedWalletsClient"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./WalletsClient"), exports);

package/codegen/Wallets/types.d.ts

@@ -0,0 +1,87 @@
+import * as Foundations from '../datamodel/Foundations';
+import * as Wallets from '../datamodel/Wallets';
+export type CreateWalletRequest = {
+    body: Wallets.CreateWalletBody;
+};
+export type CreateWalletResponse = Wallets.Wallet;
+export type GetWalletRequest = {
+    walletId: Foundations.EntityId;
+};
+export type GetWalletResponse = Wallets.Wallet;
+export type GetWalletAssetsRequest = {
+    walletId: Foundations.EntityId;
+};
+export type GetWalletAssetsResponse = Wallets.WalletAssets;
+export type GetWalletNftsRequest = {
+    walletId: Foundations.EntityId;
+};
+export type GetWalletNftsResponse = Wallets.WalletNfts;
+export type ListWalletsRequest = {
+    query?: {
+        limit?: Foundations.IntegerPositiveStrict;
+        paginationToken?: string;
+    };
+};
+export type ListWalletsResponse = Wallets.PaginatedWalletList;
+export type GetWalletHistoryRequest = {
+    walletId: Foundations.EntityId;
+    query?: {
+        limit?: Foundations.IntegerPositiveStrict;
+        paginationToken?: Foundations.IsoDatetime;
+    };
+};
+export type GetWalletHistoryResponse = Wallets.PaginatedEventHistory;
+export type TransferAssetRequest = {
+    walletId: Foundations.EntityId;
+    body: Wallets.TransferAssetBody;
+};
+export type TransferAssetResponse = Wallets.TransferRequest;
+export type GetTransferRequest = {
+    walletId: Foundations.EntityId;
+    transferId: Foundations.EntityId;
+};
+export type GetTransferResponse = Wallets.TransferRequest;
+export type ListTransfersRequest = {
+    walletId: Foundations.EntityId;
+    query?: {
+        limit?: Foundations.IntegerPositiveStrict;
+        paginationToken?: string;
+    };
+};
+export type ListTransfersResponse = Wallets.PaginatedTransferList;
+export type BroadcastTransactionRequest = {
+    walletId: Foundations.EntityId;
+    body: Wallets.BroadcastTransactionBody;
+};
+export type BroadcastTransactionResponse = Wallets.TransactionRequest;
+export type GetTransactionRequest = {
+    walletId: Foundations.EntityId;
+    transactionId: Foundations.EntityId;
+};
+export type GetTransactionResponse = Wallets.TransactionRequest;
+export type ListTransactionsRequest = {
+    walletId: Foundations.EntityId;
+    query?: {
+        limit?: Foundations.IntegerPositiveStrict;
+        paginationToken?: string;
+    };
+};
+export type ListTransactionsResponse = Wallets.PaginatedTransactionList;
+export type GenerateSignatureRequest = {
+    walletId: Foundations.EntityId;
+    body: Wallets.GenerateSignatureBody;
+};
+export type GenerateSignatureResponse = Wallets.SignatureRequest;
+export type GetSignatureRequest = {
+    walletId: Foundations.EntityId;
+    signatureId: Foundations.EntityId;
+};
+export type GetSignatureResponse = Wallets.SignatureRequest;
+export type ListSignaturesRequest = {
+    walletId: Foundations.EntityId;
+    query?: {
+        limit?: Foundations.IntegerPositiveStrict;
+        paginationToken?: string;
+    };
+};
+export type ListSignaturesResponse = Wallets.PaginatedSignatureList;

package/codegen/Wallets/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/codegen/datamodel/Assets/errors.d.ts

@@ -0,0 +1,11 @@
+import { DfnsError } from '../Foundations';
+export declare class InsufficientFunds extends DfnsError {
+    name: string;
+    serviceName: string;
+    message: string;
+    causes?: string[];
+    shouldTriggerInvestigaton: boolean;
+    isDfnsError: boolean;
+    httpStatus: number;
+    errorName: string;
+}

package/codegen/datamodel/Assets/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientFunds = void 0;
+const Foundations_1 = require("../Foundations");
+class InsufficientFunds extends Foundations_1.DfnsError {
+    constructor() {
+        super(...arguments);
+        this.name = 'InsufficientFunds';
+        // FIXME: Missing documentation for isDfnsError
+        this.isDfnsError = true;
+        // FIXME: Missing documentation for httpStatus
+        this.httpStatus = 422;
+        // FIXME: Missing documentation for errorName
+        this.errorName = 'Insufficient funds in asset account';
+    }
+}
+exports.InsufficientFunds = InsufficientFunds;

package/codegen/datamodel/Assets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './errors';
+export * from './responses';
+export * from './types';

package/codegen/datamodel/Assets/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./responses"), exports);
+__exportStar(require("./types"), exports);

package/codegen/datamodel/Assets/responses.d.ts

@@ -0,0 +1,47 @@
+import { BadRequestError, EntityNotFoundError, ForbiddenError, PaymentRequiredError, UnauthorizedError } from '../Foundations';
+import { InsufficientFunds } from './errors';
+import { AssetAccount, AssetAccountBalance, Payment } from './types';
+export type InitiatePaymentSuccess = Payment;
+export type InitiatePaymentError = {
+    error: BadRequestError | PaymentRequiredError | InsufficientFunds | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type InitiatePaymentResponse = InitiatePaymentSuccess | InitiatePaymentError;
+export type GetPaymentByIdSuccess = Payment;
+export type GetPaymentByIdError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetPaymentByIdResponse = GetPaymentByIdSuccess | GetPaymentByIdError;
+export type ListPaymentsSuccess = {
+    items: Payment[];
+};
+export type ListPaymentsError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListPaymentsResponse = ListPaymentsSuccess | ListPaymentsError;
+export type CreateAssetAccountSuccess = AssetAccount;
+export type CreateAssetAccountError = {
+    error: EntityNotFoundError | BadRequestError | PaymentRequiredError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateAssetAccountResponse = CreateAssetAccountSuccess | CreateAssetAccountError;
+export type GetAssetAccountByIdSuccess = AssetAccount;
+export type GetAssetAccountByIdError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetAssetAccountByIdResponse = GetAssetAccountByIdSuccess | GetAssetAccountByIdError;
+export type ListAssetAccountsSuccess = {
+    items: AssetAccount[];
+};
+export type ListAssetAccountsError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListAssetAccountsResponse = ListAssetAccountsSuccess | ListAssetAccountsError;
+export type ArchiveAssetAccountSuccess = AssetAccount;
+export type ArchiveAssetAccountError = {
+    error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveAssetAccountResponse = ArchiveAssetAccountSuccess | ArchiveAssetAccountError;
+export type GetAssetAccountBalanceByIdSuccess = AssetAccountBalance;
+export type GetAssetAccountBalanceByIdError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetAssetAccountBalanceByIdResponse = GetAssetAccountBalanceByIdSuccess | GetAssetAccountBalanceByIdError;

package/codegen/datamodel/Assets/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });