@dfns/sdk 0.2.2 → 0.2.3-rc.1

package/utils/fetch.ts

@@ -0,0 +1,130 @@
+import { Response, fetch as _fetch } from 'cross-fetch'
+
+import { DfnsError } from '../dfnsError'
+import { BaseAuthApi, DfnsBaseApiOptions } from '../baseAuthApi'
+import { generateNonce } from './nonce'
+import { DfnsApiClientOptions } from '../dfnsApiClient'
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE'
+
+export type FetchOptions<T> = {
+  method: HttpMethod
+  headers?: Record<string, string>
+  body?: string | unknown
+  apiOptions: T
+}
+
+export type Fetch<T> = (resource: string | URL, options: FetchOptions<T>) => Promise<Response>
+
+const fullUrl = <T extends DfnsBaseApiOptions>(fetch: Fetch<T>): Fetch<T> => {
+  return async (resource, options) => {
+    const { baseUrl } = options.apiOptions
+    resource = new URL(resource, baseUrl)
+    return fetch(resource, options)
+  }
+}
+
+const jsonSerializer = <T>(fetch: Fetch<T>): Fetch<T> => {
+  return async (resource, options) => {
+    if (options.body) {
+      options.body = JSON.stringify(options.body)
+
+      options.headers = {
+        'content-type': 'application/json',
+        ...(options.headers ?? {}),
+      }
+    }
+
+    return fetch(resource, options)
+  }
+}
+
+const errorHandler = <T>(fetch: Fetch<T>): Fetch<T> => {
+  return async (resource, options) => {
+    const response = await fetch(resource, options)
+
+    if (response.ok) {
+      return response
+    } else {
+      const body = await response.json()
+      const message = body?.error?.message ?? body?.message
+      throw new DfnsError(response.status, message, {
+        url: response.url,
+        headers: response.headers,
+        body,
+      })
+    }
+  }
+}
+
+const dfnsAuth = <T extends DfnsBaseApiOptions>(fetch: Fetch<T>): Fetch<T> => {
+  return async (resource, options) => {
+    const { appId, appSecret, authToken } = options.apiOptions
+
+    const authorization: Record<string, string> = authToken
+      ? {
+          authorization: `Bearer ${authToken}`,
+        }
+      : {}
+
+    const dfnsAppSecret: Record<string, string> = appSecret
+      ? {
+          'x-dfns-appsecret': appSecret,
+        }
+      : {}
+
+    options.headers = {
+      'x-dfns-appid': appId,
+      'x-dfns-nonce': generateNonce(),
+      ...dfnsAppSecret,
+      ...authorization,
+      ...(options.headers ?? {}),
+    }
+
+    return fetch(resource, options)
+  }
+}
+
+const userAction = <T extends DfnsApiClientOptions>(fetch: Fetch<T>): Fetch<T> => {
+  return async (resource, options) => {
+    if (options.method !== 'GET') {
+      const apiOptions = {
+        ...options.apiOptions,
+        baseUrl: (<any>options.apiOptions).baseAuthUrl || options.apiOptions.baseUrl,
+      }
+
+      const { challenge, challengeIdentifier, allowCredentials } = await BaseAuthApi.createUserActionChallenge(
+        {
+          userActionPayload: <string>options.body ?? '',
+          userActionHttpMethod: options.method,
+          userActionHttpPath: (<URL>resource).pathname,
+          userActionServerKind: (<any>apiOptions)?.userActionServerKind || 'Api',
+        },
+        apiOptions
+      )
+
+      const assertion = await apiOptions.signer.sign(challenge, allowCredentials)
+
+      const { userAction } = await BaseAuthApi.signUserActionChallenge(
+        {
+          challengeIdentifier,
+          firstFactor: assertion,
+        },
+        apiOptions
+      )
+
+      options.headers = {
+        'x-dfns-useraction': userAction,
+        ...(options.headers ?? {}),
+      }
+    }
+
+    return fetch(resource, options)
+  }
+}
+
+export const simpleFetch = fullUrl(jsonSerializer(dfnsAuth(errorHandler(<Fetch<DfnsBaseApiOptions>>_fetch))))
+
+export const userActionFetch = fullUrl(
+  jsonSerializer(dfnsAuth(userAction(errorHandler(<Fetch<DfnsApiClientOptions>>_fetch))))
+)

package/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './base64'
+export * from './fetch'
+export * from './nonce'
+export * from './url'

package/utils/nonce.ts

@@ -0,0 +1,12 @@
+import { v4 } from 'uuid'
+
+import { toBase64Url } from './base64'
+
+export const generateNonce = (): string => {
+  return toBase64Url(
+    JSON.stringify({
+      uuid: v4(),
+      date: new Date().toISOString(),
+    })
+  )
+}

package/utils/url.ts

@@ -0,0 +1,19 @@
+export const buildPathAndQuery = (
+  pattern: string,
+  params: { path: Record<string, any>; query: Record<string, string | number | boolean | undefined> }
+): string => {
+  let path = pattern
+
+  const paramsToReplace = (path.match(new RegExp(`:[a-zA-Z]+`, 'g')) || []).map((v) => v.replace(/^:/, ''))
+
+  for (const key of paramsToReplace) {
+    path = path.replace(new RegExp(`:${key}`, 'g'), encodeURIComponent(params.path[key]))
+  }
+
+  const query = Object.entries(params.query)
+    .filter(([_, value]) => !!value)
+    .map(([key, value]) => `${key}=${encodeURIComponent(value!.toString())}`)
+    .join('&')
+
+  return query === '' ? path : `${path}?${query}`
+}

package/baseAuthApi.d.ts

@@ -1,113 +0,0 @@
-import { FirstFactorAttestation, RecoveryFactorAttestation, SecondFactorAttestation, UserRegistrationChallenge } from './store';
-import { AllowCredential, CredentialKind, FirstFactorAssertion, RecoveryKeyAssertion, SecondFactorAssertion } from './signer';
-import { HttpMethod } from './utils/fetch';
-export type DfnsBaseApiOptions = {
-    appId: string;
-    appSecret?: string;
-    authToken?: string;
-    baseUrl: string;
-};
-export type CreateUserActionChallengeRequest = {
-    userActionPayload: string;
-    userActionHttpMethod: HttpMethod;
-    userActionHttpPath: string;
-    userActionServerKind: 'Api';
-};
-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 CreateUserLoginRequest = SignUserActionChallengeRequest;
-export type UserLoginResponse = {
-    token: string;
-};
-export type CreateUserRegistrationChallengeRequest = {
-    orgId: string;
-    username: string;
-    registrationCode: string;
-};
-export type UserRegistrationChallengeResponse = UserRegistrationChallenge;
-export type CreateUserRegistrationRequest = {
-    firstFactorCredential: FirstFactorAttestation;
-    secondFactorCredential?: SecondFactorAttestation;
-    recoveryCredential?: RecoveryFactorAttestation;
-};
-export type UserRegistrationResponse = {
-    credential: {
-        uuid: string;
-        kind: CredentialKind;
-        name: string;
-    };
-    user: {
-        id: string;
-        username: string;
-        orgId: string;
-    };
-};
-export type CreateUserRecoveryRequest = {
-    recovery: RecoveryKeyAssertion;
-    newCredentials: {
-        firstFactorCredential: FirstFactorAttestation;
-        secondFactorCredential?: SecondFactorAttestation;
-        recoveryCredential?: RecoveryFactorAttestation;
-    };
-};
-export type UserRecoveryResponse = UserRegistrationResponse;
-export declare class BaseAuthApi {
-    /**
-     * Creates a user action challenge
-     */
-    static createUserActionChallenge(request: CreateUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionChallengeResponse>;
-    /**
-     * Sign a user action challenge
-     */
-    static signUserActionChallenge(request: SignUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionResponse>;
-    /**
-     * Initiates user login, by creating a challenge that will need to be signed by the user Credentials.
-     */
-    static createUserLoginChallenge(request: CreateUserLoginChallengeRequest, options: DfnsBaseApiOptions): Promise<UserLoginChallengeResponse>;
-    /**
-     * Completes user login by sending the signed login challenge.
-     */
-    static createUserLogin(request: CreateUserLoginRequest, options: DfnsBaseApiOptions): Promise<UserLoginResponse>;
-    /**
-     * Completes user logout by sending the user auth token.
-     */
-    static userLogout(options: DfnsBaseApiOptions): Promise<void>;
-    /**
-     * Initiates Registration by creating a challenge that will need to be signed by a new set of Credentials.
-     */
-    static createUserRegistrationChallenge(request: CreateUserRegistrationChallengeRequest, options: DfnsBaseApiOptions): Promise<UserRegistrationChallengeResponse>;
-    /**
-     * Completes Registration by sending the signed registration challenge, containing the new Credential identity created.
-     */
-    static createUserRegistration(request: CreateUserRegistrationRequest, options: DfnsBaseApiOptions): Promise<UserRegistrationResponse>;
-    /**
-     * Completes Recovery by sending the signed recovery challenge, containing the new Credential identity created.
-     */
-    createUserRecovery(request: CreateUserRecoveryRequest, options: DfnsBaseApiOptions): Promise<UserRecoveryResponse>;
-}

package/baseAuthApi.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAuthApi = void 0;
-const fetch_1 = require("./utils/fetch");
-class BaseAuthApi {
-    /**
-     * Creates a user action challenge
-     */
-    static async createUserActionChallenge(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/action/init', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Sign a user action challenge
-     */
-    static async signUserActionChallenge(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/action', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Initiates user login, by creating a challenge that will need to be signed by the user Credentials.
-     */
-    static async createUserLoginChallenge(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/login/init', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Completes user login by sending the signed login challenge.
-     */
-    static async createUserLogin(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/login', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Completes user logout by sending the user auth token.
-     */
-    static async userLogout(options) {
-        if (!options.authToken) {
-            throw new Error('authToken is required');
-        }
-        const response = await (0, fetch_1.simpleFetch)('/auth/logout', {
-            method: 'PUT',
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Initiates Registration by creating a challenge that will need to be signed by a new set of Credentials.
-     */
-    static async createUserRegistrationChallenge(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/registration/init', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Completes Registration by sending the signed registration challenge, containing the new Credential identity created.
-     */
-    static async createUserRegistration(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/registration', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-    /**
-     * Completes Recovery by sending the signed recovery challenge, containing the new Credential identity created.
-     */
-    async createUserRecovery(request, options) {
-        const response = await (0, fetch_1.simpleFetch)('/auth/recover/user', {
-            method: 'POST',
-            body: request,
-            apiOptions: options,
-        });
-        return response.json();
-    }
-}
-exports.BaseAuthApi = BaseAuthApi;

package/codegen/Assets/AssetsClient.d.ts

@@ -1,13 +0,0 @@
-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>;
-    getAssetAccountBalanceById(request: T.GetAssetAccountBalanceByIdRequest): Promise<T.GetAssetAccountBalanceByIdResponse>;
-}

package/codegen/Assets/AssetsClient.js

@@ -1,93 +0,0 @@
-"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) {
-        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
-            path: {},
-            query: request.query ?? {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            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

@@ -1,16 +0,0 @@
-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>;
-    getAssetAccountBalanceById(request: T.GetAssetAccountBalanceByIdRequest): Promise<T.GetAssetAccountBalanceByIdResponse>;
-}

package/codegen/Assets/DelegatedAssetsClient.js

@@ -1,124 +0,0 @@
-"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) {
-        const path = (0, url_1.buildPathAndQuery)('/assets/asset-accounts', {
-            path: {},
-            query: request.query ?? {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            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

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

package/codegen/Assets/index.js

@@ -1,19 +0,0 @@
-"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);