@dfns/sdk 0.1.0-alpha.1

package/baseAuthApi.d.ts

@@ -0,0 +1,53 @@
+import { AllowCredential, FirstFactorAssertion, SecondFactorAssertion } from './signer';
+import { HttpMethod } from './utils/fetch';
+export type DfnsBaseApiOptions = {
+    appId: string;
+    appSecret?: string;
+    accessToken?: string;
+    baseUrl: string;
+};
+export type CreateUserActionChallengeRequest = {
+    userActionPayload: string;
+    userActionHttpMethod: HttpMethod;
+    userActionHttpPath: string;
+    userActionServerKind: 'Api';
+};
+export type CredentialKind = 'Key' | 'Fido2' | 'Password' | 'Totp';
+export type CredentialFactor = 'first' | 'second' | 'either';
+export type UserActionChallengeResponse = {
+    supportedCredentialKinds: {
+        kind: CredentialKind;
+        factor: CredentialFactor;
+        requiresSecondFactor: boolean;
+    }[];
+    challenge: string;
+    challengeIdentifier: string;
+    externalAuthenticationUrl: string;
+    allowCredentials: {
+        key: AllowCredential[];
+        webauthn: AllowCredential[];
+    };
+};
+export type SignUserActionChallengeRequest = {
+    challengeIdentifier: string;
+    firstFactor: FirstFactorAssertion;
+    secondFactor?: SecondFactorAssertion;
+};
+export type UserActionResponse = {
+    userAction: string;
+};
+export type CreateUserLoginChallengeRequest = {
+    username: string;
+    orgId: string;
+};
+export type UserLoginChallengeResponse = UserActionChallengeResponse;
+export type SignUserLoginChallengeRequest = SignUserActionChallengeRequest;
+export type UserLoginResponse = {
+    token: string;
+};
+export declare class BaseAuthApi {
+    static createUserActionChallenge(request: CreateUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionChallengeResponse>;
+    static signUserActionChallenge(request: SignUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionResponse>;
+    static createUserLoginChallenge(request: CreateUserLoginChallengeRequest, options: DfnsBaseApiOptions): Promise<UserLoginChallengeResponse>;
+    static signUserLoginChallenge(request: SignUserLoginChallengeRequest, options: DfnsBaseApiOptions): Promise<UserLoginResponse>;
+}

package/baseAuthApi.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAuthApi = void 0;
+const fetch_1 = require("./utils/fetch");
+class BaseAuthApi {
+    static async createUserActionChallenge(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/action/init', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
+    static async signUserActionChallenge(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/action', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
+    static async createUserLoginChallenge(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/login/init', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
+    static async signUserLoginChallenge(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/login', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
+}
+exports.BaseAuthApi = BaseAuthApi;

package/codegen/ApiKeys/ApiKeysClient.d.ts

@@ -0,0 +1,10 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class ApiKeysClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createApiKey(request: T.CreateApiKeyRequest): Promise<T.CreateApiKeyResponse>;
+    listApiKeys(): Promise<T.ListApiKeysResponse>;
+    revokeApiKey(request: T.RevokeApiKeyRequest): Promise<T.RevokeApiKeyResponse>;
+    getApiKeyById(request: T.GetApiKeyByIdRequest): Promise<T.GetApiKeyByIdResponse>;
+}

package/codegen/ApiKeys/ApiKeysClient.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeysClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class ApiKeysClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createApiKey(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listApiKeys() {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async revokeApiKey(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys/:apiKeyId', {
+            path: { apiKeyId: request.apiKeyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getApiKeyById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys/:apiKeyId', {
+            path: { apiKeyId: request.apiKeyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.ApiKeysClient = ApiKeysClient;

package/codegen/ApiKeys/DelegatedApiKeysClient.d.ts

@@ -0,0 +1,13 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedApiKeysClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createApiKeyInit(request: T.CreateApiKeyRequest): Promise<UserActionChallengeResponse>;
+    createApiKeyComplete(request: T.CreateApiKeyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateApiKeyResponse>;
+    listApiKeys(): Promise<T.ListApiKeysResponse>;
+    revokeApiKeyInit(request: T.RevokeApiKeyRequest): Promise<UserActionChallengeResponse>;
+    revokeApiKeyComplete(request: T.RevokeApiKeyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.RevokeApiKeyResponse>;
+    getApiKeyById(request: T.GetApiKeyByIdRequest): Promise<T.GetApiKeyByIdResponse>;
+}

package/codegen/ApiKeys/DelegatedApiKeysClient.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedApiKeysClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedApiKeysClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createApiKeyInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys', {
+            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 createApiKeyComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys', {
+            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 listApiKeys() {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async revokeApiKeyInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys/:apiKeyId', {
+            path: { apiKeyId: request.apiKeyId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async revokeApiKeyComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys/:apiKeyId', {
+            path: { apiKeyId: request.apiKeyId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'DELETE',
+            body: {},
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getApiKeyById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/api-keys/:apiKeyId', {
+            path: { apiKeyId: request.apiKeyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedApiKeysClient = DelegatedApiKeysClient;

package/codegen/ApiKeys/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ApiKeysClient';
+export * from './DelegatedApiKeysClient';
+export * from './types';

package/codegen/ApiKeys/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("./ApiKeysClient"), exports);
+__exportStar(require("./DelegatedApiKeysClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/ApiKeys/types.d.ts

@@ -0,0 +1,16 @@
+import * as ApiKeys from '../datamodel/ApiKeys';
+export type CreateApiKeyRequest = {
+    body: ApiKeys.CreateApiKeyInput;
+};
+export type CreateApiKeyResponse = ApiKeys.ApiKeyRecordWithToken;
+export type ListApiKeysResponse = {
+    items: ApiKeys.ApiKeyRecord[];
+};
+export type RevokeApiKeyRequest = {
+    apiKeyId: string;
+};
+export type RevokeApiKeyResponse = ApiKeys.ApiKeyRecord;
+export type GetApiKeyByIdRequest = {
+    apiKeyId: string;
+};
+export type GetApiKeyByIdResponse = ApiKeys.ApiKeyRecord;

package/codegen/ApiKeys/types.js

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

package/codegen/Assets/AssetsClient.d.ts

@@ -0,0 +1,14 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class AssetsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    initiatePayment(request: T.InitiatePaymentRequest): Promise<T.InitiatePaymentResponse>;
+    getPaymentById(request: T.GetPaymentByIdRequest): Promise<T.GetPaymentByIdResponse>;
+    listPayments(request: T.ListPaymentsRequest): Promise<T.ListPaymentsResponse>;
+    createAssetAccount(request: T.CreateAssetAccountRequest): Promise<T.CreateAssetAccountResponse>;
+    getAssetAccountById(request: T.GetAssetAccountByIdRequest): Promise<T.GetAssetAccountByIdResponse>;
+    listAssetAccounts(request: T.ListAssetAccountsRequest): Promise<T.ListAssetAccountsResponse>;
+    archiveAssetAccount(request: T.ArchiveAssetAccountRequest): Promise<T.ArchiveAssetAccountResponse>;
+    getAssetAccountBalanceById(request: T.GetAssetAccountBalanceByIdRequest): Promise<T.GetAssetAccountBalanceByIdResponse>;
+}

package/codegen/Assets/AssetsClient.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetsClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class AssetsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async initiatePayment(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPaymentById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments/:paymentId', {
+            path: {
+                assetAccountId: request.assetAccountId,
+                paymentId: request.paymentId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPayments(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createAssetAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getAssetAccountById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listAssetAccounts(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
+            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 archiveAssetAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getAssetAccountBalanceById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/balance', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.AssetsClient = AssetsClient;

package/codegen/Assets/DelegatedAssetsClient.d.ts

@@ -0,0 +1,18 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedAssetsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    initiatePaymentInit(request: T.InitiatePaymentRequest): Promise<UserActionChallengeResponse>;
+    initiatePaymentComplete(request: T.InitiatePaymentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.InitiatePaymentResponse>;
+    getPaymentById(request: T.GetPaymentByIdRequest): Promise<T.GetPaymentByIdResponse>;
+    listPayments(request: T.ListPaymentsRequest): Promise<T.ListPaymentsResponse>;
+    createAssetAccountInit(request: T.CreateAssetAccountRequest): Promise<UserActionChallengeResponse>;
+    createAssetAccountComplete(request: T.CreateAssetAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateAssetAccountResponse>;
+    getAssetAccountById(request: T.GetAssetAccountByIdRequest): Promise<T.GetAssetAccountByIdResponse>;
+    listAssetAccounts(request: T.ListAssetAccountsRequest): Promise<T.ListAssetAccountsResponse>;
+    archiveAssetAccountInit(request: T.ArchiveAssetAccountRequest): Promise<UserActionChallengeResponse>;
+    archiveAssetAccountComplete(request: T.ArchiveAssetAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveAssetAccountResponse>;
+    getAssetAccountBalanceById(request: T.GetAssetAccountBalanceByIdRequest): Promise<T.GetAssetAccountBalanceByIdResponse>;
+}

package/codegen/Assets/DelegatedAssetsClient.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedAssetsClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedAssetsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async initiatePaymentInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async initiatePaymentComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments', {
+            path: { assetAccountId: request.assetAccountId },
+            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 getPaymentById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments/:paymentId', {
+            path: {
+                assetAccountId: request.assetAccountId,
+                paymentId: request.paymentId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPayments(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/payments', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createAssetAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
+            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 createAssetAccountComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
+            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 getAssetAccountById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listAssetAccounts(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
+            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 archiveAssetAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archiveAssetAccountComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'DELETE',
+            body: {},
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getAssetAccountBalanceById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts/:assetAccountId/balance', {
+            path: { assetAccountId: request.assetAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedAssetsClient = DelegatedAssetsClient;

package/codegen/Assets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AssetsClient';
+export * from './DelegatedAssetsClient';
+export * from './types';

package/codegen/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("./AssetsClient"), exports);
+__exportStar(require("./DelegatedAssetsClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/Assets/types.d.ts

@@ -0,0 +1,39 @@
+import * as Assets from '../datamodel/Assets';
+export type InitiatePaymentRequest = {
+    assetAccountId: string;
+    body: Assets.CreatePaymentInput;
+};
+export type InitiatePaymentResponse = Assets.Payment;
+export type GetPaymentByIdRequest = {
+    assetAccountId: string;
+    paymentId: string;
+};
+export type GetPaymentByIdResponse = Assets.Payment;
+export type ListPaymentsRequest = {
+    assetAccountId: string;
+};
+export type ListPaymentsResponse = Assets.Payment;
+export type CreateAssetAccountRequest = {
+    body: Assets.CreateAssetAccountInput;
+};
+export type CreateAssetAccountResponse = Assets.AssetAccount;
+export type GetAssetAccountByIdRequest = {
+    assetAccountId: string;
+};
+export type GetAssetAccountByIdResponse = Assets.AssetAccount;
+export type ListAssetAccountsRequest = {
+    query?: {
+        status?: Assets.AssetAccountStatus;
+    };
+};
+export type ListAssetAccountsResponse = {
+    items: Assets.AssetAccount[];
+};
+export type ArchiveAssetAccountRequest = {
+    assetAccountId: string;
+};
+export type ArchiveAssetAccountResponse = Assets.AssetAccount;
+export type GetAssetAccountBalanceByIdRequest = {
+    assetAccountId: string;
+};
+export type GetAssetAccountBalanceByIdResponse = Assets.AssetAccountBalance;

package/codegen/Assets/types.js

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