@dfns/sdk 0.2.3-rc.1 → 0.2.3

package/baseAuthApi.d.ts

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

package/baseAuthApi.js

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

package/codegen/Assets/AssetsClient.d.ts

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

package/codegen/Assets/AssetsClient.js

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

package/codegen/Assets/DelegatedAssetsClient.d.ts

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

package/codegen/Assets/DelegatedAssetsClient.js

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

package/codegen/Assets/index.d.ts

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

package/codegen/Assets/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetsClient"), exports);
+__exportStar(require("./DelegatedAssetsClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/Assets/types.d.ts

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

package/codegen/Assets/types.js

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

package/codegen/Auth/AuthClient.d.ts

@@ -0,0 +1,50 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class AuthClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createDelegatedUserRegistration(request: T.CreateDelegatedUserRegistrationRequest): Promise<T.CreateDelegatedUserRegistrationResponse>;
+    createUserRegistration(request: T.CreateUserRegistrationRequest): Promise<T.CreateUserRegistrationResponse>;
+    createDelegatedUserLogin(request: T.CreateDelegatedUserLoginRequest): Promise<T.CreateDelegatedUserLoginResponse>;
+    createUserActionSignatureChallenge(request: T.CreateUserActionSignatureChallengeRequest): Promise<T.CreateUserActionSignatureChallengeResponse>;
+    createUserActionSignature(request: T.CreateUserActionSignatureRequest): Promise<T.CreateUserActionSignatureResponse>;
+    createUserCredentialChallenge(request: T.CreateUserCredentialChallengeRequest): Promise<T.CreateUserCredentialChallengeResponse>;
+    createUserCredential(request: T.CreateUserCredentialRequest): Promise<T.CreateUserCredentialResponse>;
+    activateCredential(request: T.ActivateCredentialRequest): Promise<T.ActivateCredentialResponse>;
+    deactivateCredential(request: T.DeactivateCredentialRequest): 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>;
+    createPersonalAccessToken(request: T.CreatePersonalAccessTokenRequest): Promise<T.CreatePersonalAccessTokenResponse>;
+    getPersonalAccessTokens(request: T.GetPersonalAccessTokensRequest): Promise<T.GetPersonalAccessTokensResponse>;
+    updatePersonalAccessToken(request: T.UpdatePersonalAccessTokenRequest): Promise<T.UpdatePersonalAccessTokenResponse>;
+    archivePersonalAccessToken(request: T.ArchivePersonalAccessTokenRequest): Promise<T.ArchivePersonalAccessTokenResponse>;
+    activatePersonalAccessToken(request: T.ActivatePersonalAccessTokenRequest): Promise<T.ActivatePersonalAccessTokenResponse>;
+    deactivatePersonalAccessToken(request: T.DeactivatePersonalAccessTokenRequest): Promise<T.DeactivatePersonalAccessTokenResponse>;
+    listServiceAccounts(): Promise<T.ListServiceAccountsResponse>;
+    createServiceAccount(request: T.CreateServiceAccountRequest): Promise<T.CreateServiceAccountResponse>;
+    getServiceAccount(request: T.GetServiceAccountRequest): Promise<T.GetServiceAccountResponse>;
+    updateServiceAccount(request: T.UpdateServiceAccountRequest): Promise<T.UpdateServiceAccountResponse>;
+    archiveServiceAccount(request: T.ArchiveServiceAccountRequest): Promise<T.ArchiveServiceAccountResponse>;
+    activateServiceAccount(request: T.ActivateServiceAccountRequest): Promise<T.ActivateServiceAccountResponse>;
+    deactivateServiceAccount(request: T.DeactivateServiceAccountRequest): Promise<T.DeactivateServiceAccountResponse>;
+    listUsers(): Promise<T.ListUsersResponse>;
+    createUser(request: T.CreateUserRequest): Promise<T.CreateUserResponse>;
+    getUser(request: T.GetUserRequest): Promise<T.GetUserResponse>;
+    updateUser(request: T.UpdateUserRequest): Promise<T.UpdateUserResponse>;
+    archiveUser(request: T.ArchiveUserRequest): Promise<T.ArchiveUserResponse>;
+    activateUser(request: T.ActivateUserRequest): Promise<T.ActivateUserResponse>;
+    deactivateUser(request: T.DeactivateUserRequest): Promise<T.DeactivateUserResponse>;
+    listApplications(): Promise<T.ListApplicationsResponse>;
+    createApplication(request: T.CreateApplicationRequest): Promise<T.CreateApplicationResponse>;
+    getApplication(request: T.GetApplicationRequest): Promise<T.GetApplicationResponse>;
+    updateApplication(request: T.UpdateApplicationRequest): Promise<T.UpdateApplicationResponse>;
+    archiveApplication(request: T.ArchiveApplicationRequest): Promise<T.ArchiveApplicationResponse>;
+    activateApplication(request: T.ActivateApplicationRequest): Promise<T.ActivateApplicationResponse>;
+    deactivateApplication(request: T.DeactivateApplicationRequest): Promise<T.DeactivateApplicationResponse>;
+    createUserRecovery(request: T.CreateUserRecoveryRequest): Promise<T.CreateUserRecoveryResponse>;
+    restartDelegatedUserRegistration(request: T.RestartDelegatedUserRegistrationRequest): Promise<T.RestartDelegatedUserRegistrationResponse>;
+    createDelegatedUserRecovery(request: T.CreateDelegatedUserRecoveryRequest): Promise<T.CreateDelegatedUserRecoveryResponse>;
+}