@dfns/sdk 0.2.3-rc.1 → 0.2.3

package/codegen/Auth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AuthClient';
+export * from './DelegatedAuthClient';
+export * from './types';

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

package/codegen/Auth/types.d.ts

@@ -0,0 +1,177 @@
+import * as Auth from '../datamodel/Auth';
+import * as Foundations from '../datamodel/Foundations';
+export type CreateDelegatedUserRegistrationRequest = {
+    body: Auth.CreateUserInput;
+};
+export type CreateDelegatedUserRegistrationResponse = Auth.UserRegistrationChallenge;
+export type CreateUserRegistrationRequest = {
+    body: Auth.CreateUserRegistrationInput;
+};
+export type CreateUserRegistrationResponse = Auth.UserRegistration;
+export type CreateDelegatedUserLoginRequest = {
+    body: Auth.CreateDelegatedUserLoginInput;
+};
+export type CreateDelegatedUserLoginResponse = Auth.UserLogin;
+export type CreateUserActionSignatureChallengeRequest = {
+    body: Auth.CreateUserActionSignatureChallengeInput;
+};
+export type CreateUserActionSignatureChallengeResponse = Auth.UserLoginChallenge;
+export type CreateUserActionSignatureRequest = {
+    body: Auth.CreateUserLoginInput;
+};
+export type CreateUserActionSignatureResponse = Auth.UserActionSignature;
+export type CreateUserCredentialChallengeRequest = {
+    body: Auth.CreateUserCredentialChallengeInput;
+};
+export type CreateUserCredentialChallengeResponse = Auth.UserCredentialChallenge;
+export type CreateUserCredentialRequest = {
+    body: Auth.CreateUserCredentialInput;
+};
+export type CreateUserCredentialResponse = Auth.CredentialInfo;
+export type ActivateCredentialRequest = {
+    body: Auth.ActivateCredentialInput;
+};
+export type ActivateCredentialResponse = Auth.GenericSuccessMessage;
+export type DeactivateCredentialRequest = {
+    body: Auth.ActivateCredentialInput;
+};
+export type DeactivateCredentialResponse = Auth.GenericSuccessMessage;
+export type ListUserCredentialsResponse = {
+    items: Auth.CredentialInfo[];
+};
+export type CreateUserActionSignatureFromCodeRequest = {
+    body: Auth.CreateUserLoginFromCodeInput;
+};
+export type CreateUserActionSignatureFromCodeResponse = Auth.UserActionSignature;
+export type CreateCodeUserActionSignatureChallengeRequest = {
+    body: Auth.CreateCodeLoginChallengeInput;
+};
+export type CreateCodeUserActionSignatureChallengeResponse = Auth.UserLoginChallenge;
+export type CreateCodeUserActionSignatureRequest = {
+    body: Auth.CreateUserLoginInput;
+};
+export type CreateCodeUserActionSignatureResponse = Auth.GenericSuccessMessage;
+export type ListPersonalAccessTokensResponse = {
+    items: Auth.AccessTokenInfoWithPublicKey[];
+};
+export type CreatePersonalAccessTokenRequest = {
+    body: Auth.CreateAccessTokenInput;
+};
+export type CreatePersonalAccessTokenResponse = Auth.AccessTokenInfoWithPublicKey;
+export type GetPersonalAccessTokensRequest = {
+    tokenId: Foundations.EntityId;
+};
+export type GetPersonalAccessTokensResponse = Auth.AccessTokenInfoWithPublicKey;
+export type UpdatePersonalAccessTokenRequest = {
+    tokenId: Foundations.EntityId;
+    body: Auth.UpdateAccessTokenInput;
+};
+export type UpdatePersonalAccessTokenResponse = Auth.AccessTokenInfoWithPublicKey;
+export type ArchivePersonalAccessTokenRequest = {
+    tokenId: Foundations.EntityId;
+};
+export type ArchivePersonalAccessTokenResponse = Auth.AccessTokenInfoWithPublicKey;
+export type ActivatePersonalAccessTokenRequest = {
+    tokenId: Foundations.EntityId;
+};
+export type ActivatePersonalAccessTokenResponse = Auth.AccessTokenInfoWithPublicKey;
+export type DeactivatePersonalAccessTokenRequest = {
+    tokenId: Foundations.EntityId;
+};
+export type DeactivatePersonalAccessTokenResponse = Auth.AccessTokenInfoWithPublicKey;
+export type ListServiceAccountsResponse = {
+    items: Auth.UserAccessTokenInformation[];
+};
+export type CreateServiceAccountRequest = {
+    body: Auth.CreateAccessTokenInput;
+};
+export type CreateServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type GetServiceAccountRequest = {
+    serviceAccountId: Foundations.EntityId;
+};
+export type GetServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type UpdateServiceAccountRequest = {
+    serviceAccountId: Foundations.EntityId;
+    body: Auth.UpdateAccessTokenInput;
+};
+export type UpdateServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type ArchiveServiceAccountRequest = {
+    serviceAccountId: Foundations.EntityId;
+};
+export type ArchiveServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type ActivateServiceAccountRequest = {
+    serviceAccountId: Foundations.EntityId;
+};
+export type ActivateServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type DeactivateServiceAccountRequest = {
+    serviceAccountId: Foundations.EntityId;
+};
+export type DeactivateServiceAccountResponse = Auth.UserAccessTokenInformation;
+export type ListUsersResponse = {
+    items: Auth.UserInfo[];
+};
+export type CreateUserRequest = {
+    body: Auth.CreateUserInput;
+};
+export type CreateUserResponse = Auth.UserInfo;
+export type GetUserRequest = {
+    userId: Foundations.EntityId;
+};
+export type GetUserResponse = Auth.UserInfo;
+export type UpdateUserRequest = {
+    userId: Foundations.EntityId;
+    body: Auth.UpdateUserInput;
+};
+export type UpdateUserResponse = Auth.UserInfo;
+export type ArchiveUserRequest = {
+    userId: Foundations.EntityId;
+};
+export type ArchiveUserResponse = Auth.UserInfo;
+export type ActivateUserRequest = {
+    userId: Foundations.EntityId;
+};
+export type ActivateUserResponse = Auth.UserInfo;
+export type DeactivateUserRequest = {
+    userId: Foundations.EntityId;
+};
+export type DeactivateUserResponse = Auth.UserInfo;
+export type ListApplicationsResponse = {
+    items: Auth.AppInfoWithPublicKey[];
+};
+export type CreateApplicationRequest = {
+    body: Auth.CreateApplicationInput;
+};
+export type CreateApplicationResponse = Auth.AppInfoWithPublicKey;
+export type GetApplicationRequest = {
+    appId: Foundations.EntityId;
+};
+export type GetApplicationResponse = Auth.AppInfoWithPublicKey;
+export type UpdateApplicationRequest = {
+    appId: Foundations.EntityId;
+    body: Auth.UpdateApplicationInput;
+};
+export type UpdateApplicationResponse = Auth.AppInfoWithPublicKey;
+export type ArchiveApplicationRequest = {
+    appId: Foundations.EntityId;
+};
+export type ArchiveApplicationResponse = Auth.AppInfoWithPublicKey;
+export type ActivateApplicationRequest = {
+    appId: Foundations.EntityId;
+};
+export type ActivateApplicationResponse = Auth.AppInfoWithPublicKey;
+export type DeactivateApplicationRequest = {
+    appId: Foundations.EntityId;
+};
+export type DeactivateApplicationResponse = Auth.AppInfoWithPublicKey;
+export type CreateUserRecoveryRequest = {
+    body: Auth.CreateUserRecoveryInput;
+};
+export type CreateUserRecoveryResponse = Auth.UserRegistration;
+export type RestartDelegatedUserRegistrationRequest = {
+    body: Auth.CreateUserInput;
+};
+export type RestartDelegatedUserRegistrationResponse = Auth.UserRegistrationChallenge;
+export type CreateDelegatedUserRecoveryRequest = {
+    body: Auth.CreateDelegatedUserRecoveryInput;
+};
+export type CreateDelegatedUserRecoveryResponse = Auth.UserRecoveryChallenge;

package/codegen/Auth/types.js

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

package/codegen/Blockchains/BlockchainsClient.d.ts

@@ -0,0 +1,7 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class BlockchainsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    callViewFunction(request: T.CallViewFunctionRequest): Promise<T.CallViewFunctionResponse>;
+}

package/codegen/Blockchains/BlockchainsClient.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainsClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class BlockchainsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async callViewFunction(request) {
+        const path = (0, url_1.buildPathAndQuery)('/blockchains/:network/call-read-function', {
+            path: { network: request.network },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.BlockchainsClient = BlockchainsClient;

package/codegen/Blockchains/DelegatedBlockchainsClient.d.ts

@@ -0,0 +1,7 @@
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedBlockchainsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    callViewFunction(request: T.CallViewFunctionRequest): Promise<T.CallViewFunctionResponse>;
+}

package/codegen/Blockchains/DelegatedBlockchainsClient.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedBlockchainsClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedBlockchainsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async callViewFunction(request) {
+        const path = (0, url_1.buildPathAndQuery)('/blockchains/:network/call-read-function', {
+            path: { network: request.network },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedBlockchainsClient = DelegatedBlockchainsClient;

package/codegen/Blockchains/index.d.ts

@@ -0,0 +1,3 @@
+export * from './BlockchainsClient';
+export * from './DelegatedBlockchainsClient';
+export * from './types';

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

package/codegen/Blockchains/types.d.ts

@@ -0,0 +1,6 @@
+import * as Blockchains from '../datamodel/Blockchains';
+export type CallViewFunctionRequest = {
+    network: string;
+    body: Blockchains.CallViewFunctionInput;
+};
+export type CallViewFunctionResponse = Blockchains.CallViewFunctionResult;

package/codegen/Blockchains/types.js

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

package/codegen/Callbacks/CallbacksClient.d.ts

@@ -0,0 +1,12 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class CallbacksClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createCallbackSubscription(request: T.CreateCallbackSubscriptionRequest): Promise<T.CreateCallbackSubscriptionResponse>;
+    getCallbackSubscriptionById(request: T.GetCallbackSubscriptionByIdRequest): Promise<T.GetCallbackSubscriptionByIdResponse>;
+    listCallbackSubscriptions(): Promise<T.ListCallbackSubscriptionsResponse>;
+    archiveCallbackSubscription(request: T.ArchiveCallbackSubscriptionRequest): Promise<T.ArchiveCallbackSubscriptionResponse>;
+    getCallbackEventById(request: T.GetCallbackEventByIdRequest): Promise<T.GetCallbackEventByIdResponse>;
+    listCallbackEvents(): Promise<T.ListCallbackEventsResponse>;
+}

package/codegen/Callbacks/CallbacksClient.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbacksClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class CallbacksClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createCallbackSubscription(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getCallbackSubscriptionById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions/:callbackSubscriptionId', {
+            path: { callbackSubscriptionId: request.callbackSubscriptionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listCallbackSubscriptions() {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveCallbackSubscription(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions/:callbackSubscriptionId', {
+            path: { callbackSubscriptionId: request.callbackSubscriptionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getCallbackEventById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-events/:callbackEventId', {
+            path: { callbackEventId: request.callbackEventId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listCallbackEvents() {
+        const path = (0, url_1.buildPathAndQuery)('/callback-events', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.CallbacksClient = CallbacksClient;

package/codegen/Callbacks/DelegatedCallbacksClient.d.ts

@@ -0,0 +1,15 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedCallbacksClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createCallbackSubscriptionInit(request: T.CreateCallbackSubscriptionRequest): Promise<UserActionChallengeResponse>;
+    createCallbackSubscriptionComplete(request: T.CreateCallbackSubscriptionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateCallbackSubscriptionResponse>;
+    getCallbackSubscriptionById(request: T.GetCallbackSubscriptionByIdRequest): Promise<T.GetCallbackSubscriptionByIdResponse>;
+    listCallbackSubscriptions(): Promise<T.ListCallbackSubscriptionsResponse>;
+    archiveCallbackSubscriptionInit(request: T.ArchiveCallbackSubscriptionRequest): Promise<UserActionChallengeResponse>;
+    archiveCallbackSubscriptionComplete(request: T.ArchiveCallbackSubscriptionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveCallbackSubscriptionResponse>;
+    getCallbackEventById(request: T.GetCallbackEventByIdRequest): Promise<T.GetCallbackEventByIdResponse>;
+    listCallbackEvents(): Promise<T.ListCallbackEventsResponse>;
+}

package/codegen/Callbacks/DelegatedCallbacksClient.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedCallbacksClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedCallbacksClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createCallbackSubscriptionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions', {
+            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 createCallbackSubscriptionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions', {
+            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 getCallbackSubscriptionById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions/:callbackSubscriptionId', {
+            path: { callbackSubscriptionId: request.callbackSubscriptionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listCallbackSubscriptions() {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveCallbackSubscriptionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions/:callbackSubscriptionId', {
+            path: { callbackSubscriptionId: request.callbackSubscriptionId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archiveCallbackSubscriptionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-subscriptions/:callbackSubscriptionId', {
+            path: { callbackSubscriptionId: request.callbackSubscriptionId },
+            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 getCallbackEventById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/callback-events/:callbackEventId', {
+            path: { callbackEventId: request.callbackEventId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listCallbackEvents() {
+        const path = (0, url_1.buildPathAndQuery)('/callback-events', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedCallbacksClient = DelegatedCallbacksClient;

package/codegen/Callbacks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './CallbacksClient';
+export * from './DelegatedCallbacksClient';
+export * from './types';

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

package/codegen/Callbacks/{types.ts → types.d.ts}

@@ -1,31 +1,23 @@
-import * as Callbacks from '../datamodel/Callbacks'
-
+import * as Callbacks from '../datamodel/Callbacks';
 export type CreateCallbackSubscriptionRequest = {
-  body: Callbacks.CreateCallbackSubscriptionInput
-}
-
-export type CreateCallbackSubscriptionResponse = Callbacks.CallbackSubscription
-
+    body: Callbacks.CreateCallbackSubscriptionInput;
+};
+export type CreateCallbackSubscriptionResponse = Callbacks.CallbackSubscription;
 export type GetCallbackSubscriptionByIdRequest = {
-  callbackSubscriptionId: string
-}
-
-export type GetCallbackSubscriptionByIdResponse = Callbacks.CallbackSubscription
-
+    callbackSubscriptionId: string;
+};
+export type GetCallbackSubscriptionByIdResponse = Callbacks.CallbackSubscription;
 export type ListCallbackSubscriptionsResponse = {
-  items: Callbacks.CallbackSubscription[]
-}
-
+    items: Callbacks.CallbackSubscription[];
+};
 export type ArchiveCallbackSubscriptionRequest = {
-  callbackSubscriptionId: string
-}
-
-export type ArchiveCallbackSubscriptionResponse = Callbacks.CallbackSubscription
-
+    callbackSubscriptionId: string;
+};
+export type ArchiveCallbackSubscriptionResponse = Callbacks.CallbackSubscription;
 export type GetCallbackEventByIdRequest = {
-  callbackEventId: string
-}
-
-export type GetCallbackEventByIdResponse = Callbacks.CallbackEvent
-
-export type ListCallbackEventsResponse = { items: Callbacks.CallbackEvent[] }
+    callbackEventId: string;
+};
+export type GetCallbackEventByIdResponse = Callbacks.CallbackEvent;
+export type ListCallbackEventsResponse = {
+    items: Callbacks.CallbackEvent[];
+};

package/codegen/Callbacks/types.js

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

package/codegen/Permissions/DelegatedPermissionsClient.d.ts

@@ -0,0 +1,27 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedPermissionsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createPermissionInit(request: T.CreatePermissionRequest): Promise<UserActionChallengeResponse>;
+    createPermissionComplete(request: T.CreatePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionResponse>;
+    updatePermissionInit(request: T.UpdatePermissionRequest): Promise<UserActionChallengeResponse>;
+    updatePermissionComplete(request: T.UpdatePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePermissionResponse>;
+    archivePermissionInit(request: T.ArchivePermissionRequest): Promise<UserActionChallengeResponse>;
+    archivePermissionComplete(request: T.ArchivePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePermissionResponse>;
+    getPermissionById(request: T.GetPermissionByIdRequest): Promise<T.GetPermissionByIdResponse>;
+    listPermissions(): Promise<T.ListPermissionsResponse>;
+    createPermissionPredicateInit(request: T.CreatePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    createPermissionPredicateComplete(request: T.CreatePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionPredicateResponse>;
+    updatePermissionPredicateInit(request: T.UpdatePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    updatePermissionPredicateComplete(request: T.UpdatePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePermissionPredicateResponse>;
+    archivePermissionPredicateInit(request: T.ArchivePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    archivePermissionPredicateComplete(request: T.ArchivePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePermissionPredicateResponse>;
+    listPermissionPredicates(request: T.ListPermissionPredicatesRequest): Promise<T.ListPermissionPredicatesResponse>;
+    createPermissionAssignmentInit(request: T.CreatePermissionAssignmentRequest): Promise<UserActionChallengeResponse>;
+    createPermissionAssignmentComplete(request: T.CreatePermissionAssignmentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionAssignmentResponse>;
+    revokePermissionAssignmentInit(request: T.RevokePermissionAssignmentRequest): Promise<UserActionChallengeResponse>;
+    revokePermissionAssignmentComplete(request: T.RevokePermissionAssignmentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.RevokePermissionAssignmentResponse>;
+    listPermissionAssignments(request: T.ListPermissionAssignmentsRequest): Promise<T.ListPermissionAssignmentsResponse>;
+}