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

package/baseAuthApi.d.ts

@@ -1,4 +1,5 @@
-import { AllowCredential, FirstFactorAssertion, SecondFactorAssertion } from './signer';
+import { FirstFactorAttestation, RecoveryFactorAttestation, SecondFactorAttestation, UserRegistrationChallenge } from './store';
+import { AllowCredential, CredentialKind, FirstFactorAssertion, SecondFactorAssertion } from './signer';
 import { HttpMethod } from './utils/fetch';
 export type DfnsBaseApiOptions = {
     appId: string;
@@ -12,7 +13,6 @@ export type CreateUserActionChallengeRequest = {
     userActionHttpPath: string;
     userActionServerKind: 'Api';
 };
-export type CredentialKind = 'Key' | 'Fido2' | 'Password' | 'Totp';
 export type CredentialFactor = 'first' | 'second' | 'either';
 export type UserActionChallengeResponse = {
     supportedCredentialKinds: {
@@ -41,13 +41,38 @@ export type CreateUserLoginChallengeRequest = {
     orgId: string;
 };
 export type UserLoginChallengeResponse = UserActionChallengeResponse;
-export type SignUserLoginChallengeRequest = SignUserActionChallengeRequest;
+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 declare class BaseAuthApi {
     static createUserActionChallenge(request: CreateUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionChallengeResponse>;
     static signUserActionChallenge(request: SignUserActionChallengeRequest, options: DfnsBaseApiOptions): Promise<UserActionResponse>;
     static createUserLoginChallenge(request: CreateUserLoginChallengeRequest, options: DfnsBaseApiOptions): Promise<UserLoginChallengeResponse>;
-    static signUserLoginChallenge(request: SignUserLoginChallengeRequest, options: DfnsBaseApiOptions): Promise<UserLoginResponse>;
+    static createUserLogin(request: CreateUserLoginRequest, options: DfnsBaseApiOptions): Promise<UserLoginResponse>;
+    static createUserRegistrationChallenge(request: CreateUserRegistrationChallengeRequest, options: DfnsBaseApiOptions): Promise<UserRegistrationChallengeResponse>;
+    static createUserRegistration(request: CreateUserRegistrationRequest, options: DfnsBaseApiOptions): Promise<UserRegistrationResponse>;
 }

package/baseAuthApi.js

@@ -27,7 +27,7 @@ class BaseAuthApi {
         });
         return response.json();
     }
-    static async signUserLoginChallenge(request, options) {
+    static async createUserLogin(request, options) {
         const response = await (0, fetch_1.simpleFetch)('/auth/login', {
             method: 'POST',
             body: request,
@@ -35,5 +35,21 @@ class BaseAuthApi {
         });
         return response.json();
     }
+    static async createUserRegistrationChallenge(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/registration/init', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
+    static async createUserRegistration(request, options) {
+        const response = await (0, fetch_1.simpleFetch)('/auth/registration', {
+            method: 'POST',
+            body: request,
+            apiOptions: options,
+        });
+        return response.json();
+    }
 }
 exports.BaseAuthApi = BaseAuthApi;

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>;
 }