@dfns/sdk 0.0.0-prealpha.9

package/codegen/Auth/DelegatedAuthClient.js

@@ -0,0 +1,882 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedAuthClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedAuthClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createDelegatedUserRegistrationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/registration/delegated', {
+            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 createDelegatedUserRegistrationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/registration/delegated', {
+            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 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 createDelegatedUserLoginInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/login/delegated', {
+            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 createDelegatedUserLoginComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/login/delegated', {
+            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 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 createUserCredentialInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials', {
+            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 createUserCredentialComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials', {
+            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 activateCredentialInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/activate', {
+            path: {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async activateCredentialComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/activate', {
+            path: {},
+            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 deactivateCredentialInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/deactivate', {
+            path: {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async deactivateCredentialComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/credentials/deactivate', {
+            path: {},
+            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 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 createPersonalAccessTokenInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats', {
+            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 createPersonalAccessTokenComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats', {
+            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 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 updatePersonalAccessTokenInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { 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 updatePersonalAccessTokenComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { 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 archivePersonalAccessTokenInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { 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 archivePersonalAccessTokenComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId', {
+            path: { 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 activatePersonalAccessTokenInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/activate', {
+            path: { 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 activatePersonalAccessTokenComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/activate', {
+            path: { 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 deactivatePersonalAccessTokenInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/deactivate', {
+            path: { 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 deactivatePersonalAccessTokenComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/pats/:tokenId/deactivate', {
+            path: { 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 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 createServiceAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-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 createServiceAccountComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-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 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 updateServiceAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async updateServiceAccountComplete(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: 'PUT',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archiveServiceAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archiveServiceAccountComplete(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: 'DELETE',
+            body: {},
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async activateServiceAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/activate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async activateServiceAccountComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/activate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            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 deactivateServiceAccountInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/deactivate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async deactivateServiceAccountComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/service-accounts/:serviceAccountId/deactivate', {
+            path: { serviceAccountId: request.serviceAccountId },
+            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: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createUserInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users', {
+            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 createUserComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users', {
+            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 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 updateUserInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async updateUserComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            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 archiveUserInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archiveUserComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId', {
+            path: { userId: request.userId },
+            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 activateUserInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/activate', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async activateUserComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/activate', {
+            path: { userId: request.userId },
+            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 deactivateUserInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/deactivate', {
+            path: { userId: request.userId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async deactivateUserComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/users/:userId/deactivate', {
+            path: { userId: request.userId },
+            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 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 createApplicationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps', {
+            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 createApplicationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps', {
+            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 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 updateApplicationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async updateApplicationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            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 archiveApplicationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archiveApplicationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId', {
+            path: { appId: request.appId },
+            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 activateApplicationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/activate', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async activateApplicationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/activate', {
+            path: { appId: request.appId },
+            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 deactivateApplicationInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/deactivate', {
+            path: { appId: request.appId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async deactivateApplicationComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/auth/apps/:appId/deactivate', {
+            path: { appId: request.appId },
+            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: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedAuthClient = DelegatedAuthClient;