@dfns/sdk 0.0.0-prealpha.9

package/codegen/Auth/AuthClient.js

@@ -0,0 +1,494 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class AuthClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createDelegatedUserRegistration(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/registration/delegated', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserRegistration(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/registration', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createDelegatedUserLogin(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/login/delegated', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserActionSignatureChallenge(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/action/init', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserActionSignature(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/action', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserCredentialChallenge(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/init', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserCredential(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activateCredential(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/activate', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async deactivateCredential(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/deactivate', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listUserCredentials() {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserActionSignatureFromCode(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/action/code/verify', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createCodeUserActionSignatureChallenge(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/action/code/init', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createCodeUserActionSignature(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/action/code', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPersonalAccessTokens() {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPersonalAccessToken(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPersonalAccessTokens(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { tokenId: request.tokenId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePersonalAccessToken(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { tokenId: request.tokenId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePersonalAccessToken(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { tokenId: request.tokenId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activatePersonalAccessToken(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/activate', {
+            path: { tokenId: request.tokenId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async deactivatePersonalAccessToken(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/deactivate', {
+            path: { tokenId: request.tokenId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listServiceAccounts() {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createServiceAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getServiceAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updateServiceAccount(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: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveServiceAccount(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: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activateServiceAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/activate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async deactivateServiceAccount(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/deactivate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            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: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updateUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activateUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/activate', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async deactivateUser(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/deactivate', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listApplications() {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updateApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activateApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/activate', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async deactivateApplication(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/deactivate', {
+            path: { appId: request.appId },
+            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: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.AuthClient = AuthClient;

package/codegen/Auth/DelegatedAuthClient.d.ts

@@ -0,0 +1,74 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedAuthClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createDelegatedUserRegistrationInit(request: T.CreateDelegatedUserRegistrationRequest): Promise<UserActionChallengeResponse>;
+    createDelegatedUserRegistrationComplete(request: T.CreateDelegatedUserRegistrationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateDelegatedUserRegistrationResponse>;
+    createUserRegistration(request: T.CreateUserRegistrationRequest): Promise<T.CreateUserRegistrationResponse>;
+    createDelegatedUserLoginInit(request: T.CreateDelegatedUserLoginRequest): Promise<UserActionChallengeResponse>;
+    createDelegatedUserLoginComplete(request: T.CreateDelegatedUserLoginRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateDelegatedUserLoginResponse>;
+    createUserActionSignatureChallenge(request: T.CreateUserActionSignatureChallengeRequest): Promise<T.CreateUserActionSignatureChallengeResponse>;
+    createUserActionSignature(request: T.CreateUserActionSignatureRequest): Promise<T.CreateUserActionSignatureResponse>;
+    createUserCredentialChallenge(request: T.CreateUserCredentialChallengeRequest): Promise<T.CreateUserCredentialChallengeResponse>;
+    createUserCredentialInit(request: T.CreateUserCredentialRequest): Promise<UserActionChallengeResponse>;
+    createUserCredentialComplete(request: T.CreateUserCredentialRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateUserCredentialResponse>;
+    activateCredentialInit(request: T.ActivateCredentialRequest): Promise<UserActionChallengeResponse>;
+    activateCredentialComplete(request: T.ActivateCredentialRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateCredentialResponse>;
+    deactivateCredentialInit(request: T.DeactivateCredentialRequest): Promise<UserActionChallengeResponse>;
+    deactivateCredentialComplete(request: T.DeactivateCredentialRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateCredentialResponse>;
+    listUserCredentials(): Promise<T.ListUserCredentialsResponse>;
+    createUserActionSignatureFromCode(request: T.CreateUserActionSignatureFromCodeRequest): Promise<T.CreateUserActionSignatureFromCodeResponse>;
+    createCodeUserActionSignatureChallenge(request: T.CreateCodeUserActionSignatureChallengeRequest): Promise<T.CreateCodeUserActionSignatureChallengeResponse>;
+    createCodeUserActionSignature(request: T.CreateCodeUserActionSignatureRequest): Promise<T.CreateCodeUserActionSignatureResponse>;
+    listPersonalAccessTokens(): Promise<T.ListPersonalAccessTokensResponse>;
+    createPersonalAccessTokenInit(request: T.CreatePersonalAccessTokenRequest): Promise<UserActionChallengeResponse>;
+    createPersonalAccessTokenComplete(request: T.CreatePersonalAccessTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePersonalAccessTokenResponse>;
+    getPersonalAccessTokens(request: T.GetPersonalAccessTokensRequest): Promise<T.GetPersonalAccessTokensResponse>;
+    updatePersonalAccessTokenInit(request: T.UpdatePersonalAccessTokenRequest): Promise<UserActionChallengeResponse>;
+    updatePersonalAccessTokenComplete(request: T.UpdatePersonalAccessTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePersonalAccessTokenResponse>;
+    archivePersonalAccessTokenInit(request: T.ArchivePersonalAccessTokenRequest): Promise<UserActionChallengeResponse>;
+    archivePersonalAccessTokenComplete(request: T.ArchivePersonalAccessTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePersonalAccessTokenResponse>;
+    activatePersonalAccessTokenInit(request: T.ActivatePersonalAccessTokenRequest): Promise<UserActionChallengeResponse>;
+    activatePersonalAccessTokenComplete(request: T.ActivatePersonalAccessTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivatePersonalAccessTokenResponse>;
+    deactivatePersonalAccessTokenInit(request: T.DeactivatePersonalAccessTokenRequest): Promise<UserActionChallengeResponse>;
+    deactivatePersonalAccessTokenComplete(request: T.DeactivatePersonalAccessTokenRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivatePersonalAccessTokenResponse>;
+    listServiceAccounts(): Promise<T.ListServiceAccountsResponse>;
+    createServiceAccountInit(request: T.CreateServiceAccountRequest): Promise<UserActionChallengeResponse>;
+    createServiceAccountComplete(request: T.CreateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateServiceAccountResponse>;
+    getServiceAccount(request: T.GetServiceAccountRequest): Promise<T.GetServiceAccountResponse>;
+    updateServiceAccountInit(request: T.UpdateServiceAccountRequest): Promise<UserActionChallengeResponse>;
+    updateServiceAccountComplete(request: T.UpdateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdateServiceAccountResponse>;
+    archiveServiceAccountInit(request: T.ArchiveServiceAccountRequest): Promise<UserActionChallengeResponse>;
+    archiveServiceAccountComplete(request: T.ArchiveServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveServiceAccountResponse>;
+    activateServiceAccountInit(request: T.ActivateServiceAccountRequest): Promise<UserActionChallengeResponse>;
+    activateServiceAccountComplete(request: T.ActivateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateServiceAccountResponse>;
+    deactivateServiceAccountInit(request: T.DeactivateServiceAccountRequest): Promise<UserActionChallengeResponse>;
+    deactivateServiceAccountComplete(request: T.DeactivateServiceAccountRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateServiceAccountResponse>;
+    listUsers(): Promise<T.ListUsersResponse>;
+    createUserInit(request: T.CreateUserRequest): Promise<UserActionChallengeResponse>;
+    createUserComplete(request: T.CreateUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateUserResponse>;
+    getUser(request: T.GetUserRequest): Promise<T.GetUserResponse>;
+    updateUserInit(request: T.UpdateUserRequest): Promise<UserActionChallengeResponse>;
+    updateUserComplete(request: T.UpdateUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdateUserResponse>;
+    archiveUserInit(request: T.ArchiveUserRequest): Promise<UserActionChallengeResponse>;
+    archiveUserComplete(request: T.ArchiveUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveUserResponse>;
+    activateUserInit(request: T.ActivateUserRequest): Promise<UserActionChallengeResponse>;
+    activateUserComplete(request: T.ActivateUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateUserResponse>;
+    deactivateUserInit(request: T.DeactivateUserRequest): Promise<UserActionChallengeResponse>;
+    deactivateUserComplete(request: T.DeactivateUserRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateUserResponse>;
+    listApplications(): Promise<T.ListApplicationsResponse>;
+    createApplicationInit(request: T.CreateApplicationRequest): Promise<UserActionChallengeResponse>;
+    createApplicationComplete(request: T.CreateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateApplicationResponse>;
+    getApplication(request: T.GetApplicationRequest): Promise<T.GetApplicationResponse>;
+    updateApplicationInit(request: T.UpdateApplicationRequest): Promise<UserActionChallengeResponse>;
+    updateApplicationComplete(request: T.UpdateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdateApplicationResponse>;
+    archiveApplicationInit(request: T.ArchiveApplicationRequest): Promise<UserActionChallengeResponse>;
+    archiveApplicationComplete(request: T.ArchiveApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchiveApplicationResponse>;
+    activateApplicationInit(request: T.ActivateApplicationRequest): Promise<UserActionChallengeResponse>;
+    activateApplicationComplete(request: T.ActivateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ActivateApplicationResponse>;
+    deactivateApplicationInit(request: T.DeactivateApplicationRequest): Promise<UserActionChallengeResponse>;
+    deactivateApplicationComplete(request: T.DeactivateApplicationRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.DeactivateApplicationResponse>;
+    createUserRecovery(request: T.CreateUserRecoveryRequest): Promise<T.CreateUserRecoveryResponse>;
+}