@dfns/sdk 0.1.0-alpha.2 → 0.1.0-alpha.3

package/codegen/Assets/AssetsClient.d.ts

@@ -9,6 +9,5 @@ export declare class AssetsClient {
     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

@@ -79,17 +79,6 @@ class AssetsClient {
         });
         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 },

package/codegen/Assets/DelegatedAssetsClient.d.ts

@@ -12,7 +12,5 @@ export declare class DelegatedAssetsClient {
     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

@@ -110,33 +110,6 @@ class DelegatedAssetsClient {
         });
         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 },

package/codegen/Assets/types.d.ts

@@ -12,7 +12,9 @@ export type GetPaymentByIdResponse = Assets.Payment;
 export type ListPaymentsRequest = {
     assetAccountId: string;
 };
-export type ListPaymentsResponse = Assets.Payment;
+export type ListPaymentsResponse = {
+    items: Assets.Payment[];
+};
 export type CreateAssetAccountRequest = {
     body: Assets.CreateAssetAccountInput;
 };
@@ -29,10 +31,6 @@ export type ListAssetAccountsRequest = {
 export type ListAssetAccountsResponse = {
     items: Assets.AssetAccount[];
 };
-export type ArchiveAssetAccountRequest = {
-    assetAccountId: string;
-};
-export type ArchiveAssetAccountResponse = Assets.AssetAccount;
 export type GetAssetAccountBalanceByIdRequest = {
     assetAccountId: string;
 };

package/codegen/Auth/AuthClient.d.ts

@@ -30,13 +30,6 @@ export declare class AuthClient {
     archiveServiceAccount(request: T.ArchiveServiceAccountRequest): Promise<T.ArchiveServiceAccountResponse>;
     activateServiceAccount(request: T.ActivateServiceAccountRequest): Promise<T.ActivateServiceAccountResponse>;
     deactivateServiceAccount(request: T.DeactivateServiceAccountRequest): Promise<T.DeactivateServiceAccountResponse>;
-    listServiceAccountTokens(request: T.ListServiceAccountTokensRequest): Promise<T.ListServiceAccountTokensResponse>;
-    createServiceAccountToken(request: T.CreateServiceAccountTokenRequest): Promise<T.CreateServiceAccountTokenResponse>;
-    getServiceAccountToken(request: T.GetServiceAccountTokenRequest): Promise<T.GetServiceAccountTokenResponse>;
-    updateServiceAccountToken(request: T.UpdateServiceAccountTokenRequest): Promise<T.UpdateServiceAccountTokenResponse>;
-    archiveServiceAccountToken(request: T.ArchiveServiceAccountTokenRequest): Promise<T.ArchiveServiceAccountTokenResponse>;
-    activateServiceAccountToken(request: T.ActivateServiceAccountTokenRequest): Promise<T.ActivateServiceAccountTokenResponse>;
-    deactivateServiceAccountToken(request: T.DeactivateServiceAccountTokenRequest): Promise<T.DeactivateServiceAccountTokenResponse>;
     listUsers(): Promise<T.ListUsersResponse>;
     createUser(request: T.CreateUserRequest): Promise<T.CreateUserResponse>;
     getUser(request: T.GetUserRequest): Promise<T.GetUserResponse>;
@@ -51,12 +44,5 @@ export declare class AuthClient {
     archiveApplication(request: T.ArchiveApplicationRequest): Promise<T.ArchiveApplicationResponse>;
     activateApplication(request: T.ActivateApplicationRequest): Promise<T.ActivateApplicationResponse>;
     deactivateApplication(request: T.DeactivateApplicationRequest): Promise<T.DeactivateApplicationResponse>;
-    listApplicationTokens(request: T.ListApplicationTokensRequest): Promise<T.ListApplicationTokensResponse>;
-    createApplicationToken(request: T.CreateApplicationTokenRequest): Promise<T.CreateApplicationTokenResponse>;
-    getApplicationToken(request: T.GetApplicationTokenRequest): Promise<T.GetApplicationTokenResponse>;
-    updateApplicationToken(request: T.UpdateApplicationTokenRequest): Promise<T.UpdateApplicationTokenResponse>;
-    archiveApplicationToken(request: T.ArchiveApplicationTokenRequest): Promise<T.ArchiveApplicationTokenResponse>;
-    activateApplicationToken(request: T.ActivateApplicationTokenRequest): Promise<T.ActivateApplicationTokenResponse>;
-    deactivateApplicationToken(request: T.DeactivateApplicationTokenRequest): Promise<T.DeactivateApplicationTokenResponse>;
     createUserRecovery(request: T.CreateUserRecoveryRequest): Promise<T.CreateUserRecoveryResponse>;
 }

package/codegen/Auth/AuthClient.js

@@ -320,100 +320,6 @@ class AuthClient {
         });
         return response.json();
     }
-    async listServiceAccountTokens(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens', {
-            path: { serviceAccountId: request.serviceAccountId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async createServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
-            path: { serviceAccountId: request.serviceAccountId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'POST',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async getServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async updateServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async archiveServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'DELETE',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async activateServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/activate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async deactivateServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/deactivate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async listUsers() {
         const path = (0, url_1.buildPathAndQuery)('/auth/users', {
             path: {},
@@ -572,85 +478,6 @@ class AuthClient {
         });
         return response.json();
     }
-    async listApplicationTokens(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens', {
-            path: { appId: request.appId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async createApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens', {
-            path: { appId: request.appId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'POST',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async getApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async updateApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async archiveApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'DELETE',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async activateApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/activate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async deactivateApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/deactivate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async createUserRecovery(request) {
         const path = (0, url_1.buildPathAndQuery)('/auth/recover/user', {
             path: {},

package/codegen/Auth/DelegatedAuthClient.d.ts

@@ -46,18 +46,6 @@ export declare class DelegatedAuthClient {
     activateServiceAccountComplete(request: T.ActivateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateServiceAccountResponse>;
     deactivateServiceAccountInit(request: T.DeactivateServiceAccountRequest): Promise<UserActionChallengeResponse>;
     deactivateServiceAccountComplete(request: T.DeactivateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateServiceAccountResponse>;
-    listServiceAccountTokens(request: T.ListServiceAccountTokensRequest): Promise<T.ListServiceAccountTokensResponse>;
-    createServiceAccountTokenInit(request: T.CreateServiceAccountTokenRequest): Promise<UserActionChallengeResponse>;
-    createServiceAccountTokenComplete(request: T.CreateServiceAccountTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateServiceAccountTokenResponse>;
-    getServiceAccountToken(request: T.GetServiceAccountTokenRequest): Promise<T.GetServiceAccountTokenResponse>;
-    updateServiceAccountTokenInit(request: T.UpdateServiceAccountTokenRequest): Promise<UserActionChallengeResponse>;
-    updateServiceAccountTokenComplete(request: T.UpdateServiceAccountTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdateServiceAccountTokenResponse>;
-    archiveServiceAccountTokenInit(request: T.ArchiveServiceAccountTokenRequest): Promise<UserActionChallengeResponse>;
-    archiveServiceAccountTokenComplete(request: T.ArchiveServiceAccountTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveServiceAccountTokenResponse>;
-    activateServiceAccountTokenInit(request: T.ActivateServiceAccountTokenRequest): Promise<UserActionChallengeResponse>;
-    activateServiceAccountTokenComplete(request: T.ActivateServiceAccountTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateServiceAccountTokenResponse>;
-    deactivateServiceAccountTokenInit(request: T.DeactivateServiceAccountTokenRequest): Promise<UserActionChallengeResponse>;
-    deactivateServiceAccountTokenComplete(request: T.DeactivateServiceAccountTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateServiceAccountTokenResponse>;
     listUsers(): Promise<T.ListUsersResponse>;
     createUserInit(request: T.CreateUserRequest): Promise<UserActionChallengeResponse>;
     createUserComplete(request: T.CreateUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateUserResponse>;
@@ -82,17 +70,5 @@ export declare class DelegatedAuthClient {
     activateApplicationComplete(request: T.ActivateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateApplicationResponse>;
     deactivateApplicationInit(request: T.DeactivateApplicationRequest): Promise<UserActionChallengeResponse>;
     deactivateApplicationComplete(request: T.DeactivateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateApplicationResponse>;
-    listApplicationTokens(request: T.ListApplicationTokensRequest): Promise<T.ListApplicationTokensResponse>;
-    createApplicationTokenInit(request: T.CreateApplicationTokenRequest): Promise<UserActionChallengeResponse>;
-    createApplicationTokenComplete(request: T.CreateApplicationTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateApplicationTokenResponse>;
-    getApplicationToken(request: T.GetApplicationTokenRequest): Promise<T.GetApplicationTokenResponse>;
-    updateApplicationTokenInit(request: T.UpdateApplicationTokenRequest): Promise<UserActionChallengeResponse>;
-    updateApplicationTokenComplete(request: T.UpdateApplicationTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdateApplicationTokenResponse>;
-    archiveApplicationTokenInit(request: T.ArchiveApplicationTokenRequest): Promise<UserActionChallengeResponse>;
-    archiveApplicationTokenComplete(request: T.ArchiveApplicationTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveApplicationTokenResponse>;
-    activateApplicationTokenInit(request: T.ActivateApplicationTokenRequest): Promise<UserActionChallengeResponse>;
-    activateApplicationTokenComplete(request: T.ActivateApplicationTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateApplicationTokenResponse>;
-    deactivateApplicationTokenInit(request: T.DeactivateApplicationTokenRequest): Promise<UserActionChallengeResponse>;
-    deactivateApplicationTokenComplete(request: T.DeactivateApplicationTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateApplicationTokenResponse>;
     createUserRecovery(request: T.CreateUserRecoveryRequest): Promise<T.CreateUserRecoveryResponse>;
 }

package/codegen/Auth/DelegatedAuthClient.js

@@ -552,190 +552,6 @@ class DelegatedAuthClient {
         });
         return response.json();
     }
-    async listServiceAccountTokens(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens', {
-            path: { serviceAccountId: request.serviceAccountId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async createServiceAccountTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
-            path: { serviceAccountId: request.serviceAccountId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'POST',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async createServiceAccountTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
-            path: { serviceAccountId: request.serviceAccountId },
-            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 getServiceAccountToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async updateServiceAccountTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async updateServiceAccountTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async archiveServiceAccountTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'DELETE',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async archiveServiceAccountTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            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 activateServiceAccountTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/activate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async activateServiceAccountTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/activate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: {},
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async deactivateServiceAccountTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/deactivate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async deactivateServiceAccountTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/tokens/:tokenId/deactivate', {
-            path: {
-                serviceAccountId: request.serviceAccountId,
-                tokenId: request.tokenId,
-            },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: {},
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async listUsers() {
         const path = (0, url_1.buildPathAndQuery)('/auth/users', {
             path: {},
@@ -1050,163 +866,6 @@ class DelegatedAuthClient {
         });
         return response.json();
     }
-    async listApplicationTokens(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens', {
-            path: { appId: request.appId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async createApplicationTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens', {
-            path: { appId: request.appId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'POST',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async createApplicationTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens', {
-            path: { appId: request.appId },
-            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 getApplicationToken(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'GET',
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async updateApplicationTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async updateApplicationTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/tokens/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async archiveApplicationTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'DELETE',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async archiveApplicationTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            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 activateApplicationTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/activate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async activateApplicationTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/activate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: {},
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
-    async deactivateApplicationTokenInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/deactivate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify({}),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async deactivateApplicationTokenComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/token/:tokenId/deactivate', {
-            path: { appId: request.appId, tokenId: request.tokenId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: {},
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async createUserRecovery(request) {
         const path = (0, url_1.buildPathAndQuery)('/auth/recover/user', {
             path: {},

package/codegen/Auth/types.d.ts

@@ -107,43 +107,6 @@ export type DeactivateServiceAccountRequest = {
     serviceAccountId: Foundations.EntityId;
 };
 export type DeactivateServiceAccountResponse = Auth.UserAccessTokenInformation;
-export type ListServiceAccountTokensRequest = {
-    serviceAccountId: Foundations.EntityId;
-};
-export type ListServiceAccountTokensResponse = {
-    items: Auth.AccessTokenInfoWithPublicKey[];
-};
-export type CreateServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    body: Auth.CreateAccessTokenInput;
-};
-export type CreateServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type GetServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type GetServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type UpdateServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-    body: Auth.UpdateAccessTokenInput;
-};
-export type UpdateServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type ArchiveServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type ArchiveServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type ActivateServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type ActivateServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type DeactivateServiceAccountTokenRequest = {
-    serviceAccountId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type DeactivateServiceAccountTokenResponse = Auth.AccessTokenInfoWithPublicKey;
 export type ListUsersResponse = {
     items: Auth.UserInfo[];
 };
@@ -200,43 +163,6 @@ export type DeactivateApplicationRequest = {
     appId: Foundations.EntityId;
 };
 export type DeactivateApplicationResponse = Auth.AppInfoWithPublicKey;
-export type ListApplicationTokensRequest = {
-    appId: Foundations.EntityId;
-};
-export type ListApplicationTokensResponse = {
-    items: Auth.AccessTokenInfoWithPublicKey[];
-};
-export type CreateApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    body: Auth.CreateAccessTokenInput;
-};
-export type CreateApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type GetApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type GetApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type UpdateApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-    body: Auth.UpdateAccessTokenInput;
-};
-export type UpdateApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type ArchiveApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type ArchiveApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type ActivateApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type ActivateApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
-export type DeactivateApplicationTokenRequest = {
-    appId: Foundations.EntityId;
-    tokenId: Foundations.EntityId;
-};
-export type DeactivateApplicationTokenResponse = Auth.AccessTokenInfoWithPublicKey;
 export type CreateUserRecoveryRequest = {
     body: Auth.CreateUserLoginChallengeInput;
 };

package/codegen/Permissions/DelegatedPermissionsClient.d.ts

@@ -24,5 +24,4 @@ export declare class DelegatedPermissionsClient {
     revokePermissionAssignmentInit(request: T.RevokePermissionAssignmentRequest): Promise<UserActionChallengeResponse>;
     revokePermissionAssignmentComplete(request: T.RevokePermissionAssignmentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.RevokePermissionAssignmentResponse>;
     listPermissionAssignments(request: T.ListPermissionAssignmentsRequest): Promise<T.ListPermissionAssignmentsResponse>;
-    listPermissionsHistorical(request: T.ListPermissionsHistoricalRequest): Promise<T.ListPermissionsHistoricalResponse>;
 }

package/codegen/Permissions/DelegatedPermissionsClient.js

@@ -281,17 +281,5 @@ class DelegatedPermissionsClient {
         });
         return response.json();
     }
-    async listPermissionsHistorical(request) {
-        var _a;
-        const path = (0, url_1.buildPathAndQuery)('/audit/permissions', {
-            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();
-    }
 }
 exports.DelegatedPermissionsClient = DelegatedPermissionsClient;

package/codegen/Permissions/PermissionsClient.d.ts

@@ -15,5 +15,4 @@ export declare class PermissionsClient {
     createPermissionAssignment(request: T.CreatePermissionAssignmentRequest): Promise<T.CreatePermissionAssignmentResponse>;
     revokePermissionAssignment(request: T.RevokePermissionAssignmentRequest): Promise<T.RevokePermissionAssignmentResponse>;
     listPermissionAssignments(request: T.ListPermissionAssignmentsRequest): Promise<T.ListPermissionAssignmentsResponse>;
-    listPermissionsHistorical(request: T.ListPermissionsHistoricalRequest): Promise<T.ListPermissionsHistoricalResponse>;
 }

package/codegen/Permissions/PermissionsClient.js

@@ -153,17 +153,5 @@ class PermissionsClient {
         });
         return response.json();
     }
-    async listPermissionsHistorical(request) {
-        var _a;
-        const path = (0, url_1.buildPathAndQuery)('/audit/permissions', {
-            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();
-    }
 }
 exports.PermissionsClient = PermissionsClient;

package/codegen/Permissions/types.d.ts

@@ -61,11 +61,3 @@ export type ListPermissionAssignmentsRequest = {
 export type ListPermissionAssignmentsResponse = {
     items: Permissions.PermissionAssignment[];
 };
-export type ListPermissionsHistoricalRequest = {
-    query?: {
-        permissionName?: string;
-    };
-};
-export type ListPermissionsHistoricalResponse = {
-    items: Permissions.Permission[];
-};

package/codegen/PolicyExecution/types.d.ts

@@ -4,7 +4,9 @@ export type ListPolicyControlExecutionsRequest = {
         activityId: string;
     };
 };
-export type ListPolicyControlExecutionsResponse = PolicyExecution.PolicyControlExecution;
+export type ListPolicyControlExecutionsResponse = {
+    items: PolicyExecution.PolicyControlExecution[];
+};
 export type GetPolicyControlExecutionByIdRequest = {
     policyControlExecutionId: string;
 };

package/codegen/PolicyManagement/DelegatedPolicyManagementClient.d.ts

@@ -6,24 +6,18 @@ export declare class DelegatedPolicyManagementClient {
     constructor(apiOptions: DfnsDelegatedApiClientOptions);
     createPolicyInit(request: T.CreatePolicyRequest): Promise<UserActionChallengeResponse>;
     createPolicyComplete(request: T.CreatePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyResponse>;
-    updatePolicyInit(request: T.UpdatePolicyRequest): Promise<UserActionChallengeResponse>;
-    updatePolicyComplete(request: T.UpdatePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePolicyResponse>;
     getPolicyById(request: T.GetPolicyByIdRequest): Promise<T.GetPolicyByIdResponse>;
     listPolicies(request: T.ListPoliciesRequest): Promise<T.ListPoliciesResponse>;
     archivePolicyInit(request: T.ArchivePolicyRequest): Promise<UserActionChallengeResponse>;
     archivePolicyComplete(request: T.ArchivePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyResponse>;
     createPolicyControlInit(request: T.CreatePolicyControlRequest): Promise<UserActionChallengeResponse>;
     createPolicyControlComplete(request: T.CreatePolicyControlRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyControlResponse>;
-    updatePolicyControlInit(request: T.UpdatePolicyControlRequest): Promise<UserActionChallengeResponse>;
-    updatePolicyControlComplete(request: T.UpdatePolicyControlRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePolicyControlResponse>;
     getPolicyControlById(request: T.GetPolicyControlByIdRequest): Promise<T.GetPolicyControlByIdResponse>;
     listPolicyControls(request: T.ListPolicyControlsRequest): Promise<T.ListPolicyControlsResponse>;
     archivePolicyControlInit(request: T.ArchivePolicyControlRequest): Promise<UserActionChallengeResponse>;
     archivePolicyControlComplete(request: T.ArchivePolicyControlRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyControlResponse>;
     createPolicyRuleInit(request: T.CreatePolicyRuleRequest): Promise<UserActionChallengeResponse>;
     createPolicyRuleComplete(request: T.CreatePolicyRuleRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyRuleResponse>;
-    updatePolicyRuleInit(request: T.UpdatePolicyRuleRequest): Promise<UserActionChallengeResponse>;
-    updatePolicyRuleComplete(request: T.UpdatePolicyRuleRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePolicyRuleResponse>;
     getPolicyRuleById(request: T.GetPolicyRuleByIdRequest): Promise<T.GetPolicyRuleByIdResponse>;
     listPolicyRules(request: T.ListPolicyRulesRequest): Promise<T.ListPolicyRulesResponse>;
     archivePolicyRuleInit(request: T.ArchivePolicyRuleRequest): Promise<UserActionChallengeResponse>;

package/codegen/PolicyManagement/DelegatedPolicyManagementClient.js

@@ -35,33 +35,6 @@ class DelegatedPolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicyInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
-            path: { policyId: request.policyId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async updatePolicyComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
-            path: { policyId: request.policyId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
             path: { policyId: request.policyId },
@@ -139,33 +112,6 @@ class DelegatedPolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicyControlInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
-            path: { policyControlId: request.policyControlId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async updatePolicyControlComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
-            path: { policyControlId: request.policyControlId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyControlById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
             path: { policyControlId: request.policyControlId },
@@ -243,33 +189,6 @@ class DelegatedPolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicyRuleInit(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
-            path: { policyRuleId: request.policyRuleId },
-            query: {},
-        });
-        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
-            userActionHttpMethod: 'PUT',
-            userActionHttpPath: path,
-            userActionPayload: JSON.stringify(request.body),
-            userActionServerKind: 'Api',
-        }, this.apiOptions);
-        return challenge;
-    }
-    async updatePolicyRuleComplete(request, signedChallenge) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
-            path: { policyRuleId: request.policyRuleId },
-            query: {},
-        });
-        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
-        const response = await (0, fetch_1.simpleFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            headers: { 'x-dfns-useraction': userAction },
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyRuleById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
             path: { policyRuleId: request.policyRuleId },

package/codegen/PolicyManagement/PolicyManagementClient.d.ts

@@ -4,17 +4,14 @@ export declare class PolicyManagementClient {
     private apiOptions;
     constructor(apiOptions: DfnsApiClientOptions);
     createPolicy(request: T.CreatePolicyRequest): Promise<T.CreatePolicyResponse>;
-    updatePolicy(request: T.UpdatePolicyRequest): Promise<T.UpdatePolicyResponse>;
     getPolicyById(request: T.GetPolicyByIdRequest): Promise<T.GetPolicyByIdResponse>;
     listPolicies(request: T.ListPoliciesRequest): Promise<T.ListPoliciesResponse>;
     archivePolicy(request: T.ArchivePolicyRequest): Promise<T.ArchivePolicyResponse>;
     createPolicyControl(request: T.CreatePolicyControlRequest): Promise<T.CreatePolicyControlResponse>;
-    updatePolicyControl(request: T.UpdatePolicyControlRequest): Promise<T.UpdatePolicyControlResponse>;
     getPolicyControlById(request: T.GetPolicyControlByIdRequest): Promise<T.GetPolicyControlByIdResponse>;
     listPolicyControls(request: T.ListPolicyControlsRequest): Promise<T.ListPolicyControlsResponse>;
     archivePolicyControl(request: T.ArchivePolicyControlRequest): Promise<T.ArchivePolicyControlResponse>;
     createPolicyRule(request: T.CreatePolicyRuleRequest): Promise<T.CreatePolicyRuleResponse>;
-    updatePolicyRule(request: T.UpdatePolicyRuleRequest): Promise<T.UpdatePolicyRuleResponse>;
     getPolicyRuleById(request: T.GetPolicyRuleByIdRequest): Promise<T.GetPolicyRuleByIdResponse>;
     listPolicyRules(request: T.ListPolicyRulesRequest): Promise<T.ListPolicyRulesResponse>;
     archivePolicyRule(request: T.ArchivePolicyRuleRequest): Promise<T.ArchivePolicyRuleResponse>;

package/codegen/PolicyManagement/PolicyManagementClient.js

@@ -19,18 +19,6 @@ class PolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicy(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
-            path: { policyId: request.policyId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
             path: { policyId: request.policyId },
@@ -77,18 +65,6 @@ class PolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicyControl(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
-            path: { policyControlId: request.policyControlId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyControlById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
             path: { policyControlId: request.policyControlId },
@@ -135,18 +111,6 @@ class PolicyManagementClient {
         });
         return response.json();
     }
-    async updatePolicyRule(request) {
-        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
-            path: { policyRuleId: request.policyRuleId },
-            query: {},
-        });
-        const response = await (0, fetch_1.userActionFetch)(path, {
-            method: 'PUT',
-            body: request.body,
-            apiOptions: this.apiOptions,
-        });
-        return response.json();
-    }
     async getPolicyRuleById(request) {
         const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
             path: { policyRuleId: request.policyRuleId },

package/codegen/PolicyManagement/types.d.ts

@@ -3,11 +3,6 @@ export type CreatePolicyRequest = {
     body: PolicyManagement.CreatePolicyInput;
 };
 export type CreatePolicyResponse = PolicyManagement.Policy;
-export type UpdatePolicyRequest = {
-    policyId: string;
-    body: PolicyManagement.UpdatePolicyInput;
-};
-export type UpdatePolicyResponse = PolicyManagement.Policy;
 export type GetPolicyByIdRequest = {
     policyId: string;
 };
@@ -33,11 +28,6 @@ export type CreatePolicyControlRequest = {
     body: PolicyManagement.CreatePolicyControlInput;
 };
 export type CreatePolicyControlResponse = PolicyManagement.PolicyControl;
-export type UpdatePolicyControlRequest = {
-    policyControlId: string;
-    body: PolicyManagement.UpdatePolicyControlInput;
-};
-export type UpdatePolicyControlResponse = PolicyManagement.PolicyControl;
 export type GetPolicyControlByIdRequest = {
     policyControlId: string;
 };
@@ -63,11 +53,6 @@ export type CreatePolicyRuleRequest = {
     body: PolicyManagement.CreatePolicyInput;
 };
 export type CreatePolicyRuleResponse = PolicyManagement.Policy;
-export type UpdatePolicyRuleRequest = {
-    policyRuleId: string;
-    body: PolicyManagement.UpdatePolicyInput;
-};
-export type UpdatePolicyRuleResponse = PolicyManagement.Policy;
 export type GetPolicyRuleByIdRequest = {
     policyRuleId: string;
 };

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

@@ -11,7 +11,9 @@ export type GetPaymentByIdError = {
     error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
 };
 export type GetPaymentByIdResponse = GetPaymentByIdSuccess | GetPaymentByIdError;
-export type ListPaymentsSuccess = Payment;
+export type ListPaymentsSuccess = {
+    items: Payment[];
+};
 export type ListPaymentsError = {
     error: EntityNotFoundError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
 };

package/codegen/datamodel/Foundations/types.d.ts

@@ -333,6 +333,7 @@ export declare enum AssetSymbol {
     sFUEL = "sFUEL",
     ARB = "ARB",
     AMB = "AMB",
+    CMP = "CMP",
     LTC = "LTC",
     KSM = "KSM",
     TRX = "TRX",
@@ -9745,7 +9746,8 @@ export declare enum BlockchainNetwork {
     XTZ = "XTZ",
     sFUEL = "sFUEL",
     EGLD = "EGLD",
-    AMB = "AMB"
+    AMB = "AMB",
+    CMP = "CMP"
 }
 export type BlockchainNetworkMetadata = {
     label: string;

package/codegen/datamodel/Foundations/types.js

@@ -1266,6 +1266,8 @@ var AssetSymbol;
     AssetSymbol["ARB"] = "ARB";
     //AirDAO native currency
     AssetSymbol["AMB"] = "AMB";
+    //Caduceus native currency
+    AssetSymbol["CMP"] = "CMP";
     //Lite Coin native currency
     AssetSymbol["LTC"] = "LTC";
     //Kusama – Polkadot’s Canary network
@@ -20060,6 +20062,10 @@ exports.ASSET_SYMBOL_DATA = {
         label: `AirDAO`,
         smallestUnitDecimal: 18,
     },
+    [AssetSymbol['CMP']]: {
+        label: `CMP`,
+        smallestUnitDecimal: 18,
+    },
     [AssetSymbol['LTC']]: {
         label: `Litecoin`,
         smallestUnitDecimal: 8,
@@ -57596,6 +57602,8 @@ var BlockchainNetwork;
     BlockchainNetwork["EGLD"] = "EGLD";
     //AirDAO
     BlockchainNetwork["AMB"] = "AMB";
+    //Caduceus
+    BlockchainNetwork["CMP"] = "CMP";
 })(BlockchainNetwork = exports.BlockchainNetwork || (exports.BlockchainNetwork = {}));
 exports.BLOCKCHAIN_NETWORK_DATA = {
     [BlockchainNetwork['ADA']]: {
@@ -57738,4 +57746,8 @@ exports.BLOCKCHAIN_NETWORK_DATA = {
         label: `AirDAO`,
         smallestUnitDecimal: 18,
     },
+    [BlockchainNetwork['CMP']]: {
+        label: `Caduceus`,
+        smallestUnitDecimal: 18,
+    },
 };

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

@@ -1,6 +1,8 @@
 import { BadRequestError, EntityNotFoundError, ForbiddenError, UnauthorizedError } from '../Foundations';
 import { PolicyControlExecution } from './types';
-export type ListPolicyControlExecutionsSuccess = PolicyControlExecution;
+export type ListPolicyControlExecutionsSuccess = {
+    items: PolicyControlExecution[];
+};
 export type ListPolicyControlExecutionsError = {
     error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfns/sdk",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.3",
   "dependencies": {
     "buffer": "^6.0.3",
     "cross-fetch": "^3.1.6",