@authsome/client 0.0.3 → 0.0.4

package/dist/plugins/consent.js

@@ -16,18 +16,18 @@ class ConsentPlugin {
             body: request,
         });
     }
-    async getConsent() {
-        const path = '/records/:id';
+    async getConsent(params) {
+        const path = `/records/${params.id}`;
         return this.client.request('GET', path);
     }
-    async updateConsent(request) {
-        const path = '/records/:id';
+    async updateConsent(params, request) {
+        const path = `/records/${params.id}`;
         return this.client.request('PUT', path, {
             body: request,
         });
     }
-    async revokeConsent(request) {
-        const path = '/revoke/:id';
+    async revokeConsent(params, request) {
+        const path = `/revoke/${params.id}`;
         return this.client.request('POST', path, {
             body: request,
         });
@@ -38,8 +38,8 @@ class ConsentPlugin {
             body: request,
         });
     }
-    async getConsentPolicy() {
-        const path = '/policies/:id';
+    async getConsentPolicy(params) {
+        const path = `/policies/${params.id}`;
         return this.client.request('GET', path);
     }
     async recordCookieConsent(request) {
@@ -58,12 +58,12 @@ class ConsentPlugin {
             body: request,
         });
     }
-    async getDataExport() {
-        const path = '/export/:id';
+    async getDataExport(params) {
+        const path = `/export/${params.id}`;
         return this.client.request('GET', path);
     }
-    async downloadDataExport() {
-        const path = '/export/:id/download';
+    async downloadDataExport(params) {
+        const path = `/export/${params.id}/download`;
         return this.client.request('GET', path);
     }
     async requestDataDeletion(request) {
@@ -72,12 +72,12 @@ class ConsentPlugin {
             body: request,
         });
     }
-    async getDataDeletion() {
-        const path = '/deletion/:id';
+    async getDataDeletion(params) {
+        const path = `/deletion/${params.id}`;
         return this.client.request('GET', path);
     }
-    async approveDeletionRequest() {
-        const path = '/deletion/:id/approve';
+    async approveDeletionRequest(params) {
+        const path = `/deletion/${params.id}/approve`;
         return this.client.request('POST', path);
     }
     async getPrivacySettings() {

package/dist/plugins/emailverification.d.ts

@@ -0,0 +1,12 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class EmailverificationPlugin implements ClientPlugin {
+    readonly id = "emailverification";
+    private client;
+    init(client: AuthsomeClient): void;
+    send(request: types.SendRequest): Promise<void>;
+    verify(): Promise<void>;
+    resend(request: types.ResendRequest): Promise<types.ResendResponse>;
+}
+export declare function emailverificationClient(): EmailverificationPlugin;

package/dist/plugins/emailverification.js

@@ -0,0 +1,33 @@
+"use strict";
+// Auto-generated emailverification plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailverificationPlugin = void 0;
+exports.emailverificationClient = emailverificationClient;
+class EmailverificationPlugin {
+    constructor() {
+        this.id = 'emailverification';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async send(request) {
+        const path = '/email-verification/send';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async verify() {
+        const path = '/email-verification/verify';
+        return this.client.request('GET', path);
+    }
+    async resend(request) {
+        const path = '/email-verification/resend';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+}
+exports.EmailverificationPlugin = EmailverificationPlugin;
+function emailverificationClient() {
+    return new EmailverificationPlugin();
+}

package/dist/plugins/idverification.d.ts

@@ -6,15 +6,29 @@ export declare class IdverificationPlugin implements ClientPlugin {
     private client;
     init(client: AuthsomeClient): void;
     createVerificationSession(request: types.CreateVerificationSession_req): Promise<types.VerificationSessionResponse>;
-    getVerificationSession(): Promise<types.VerificationSessionResponse>;
-    getVerification(): Promise<types.VerificationResponse>;
+    getVerificationSession(params: {
+        id: string;
+    }): Promise<types.VerificationSessionResponse>;
+    getVerification(params: {
+        id: string;
+    }): Promise<types.VerificationResponse>;
     getUserVerifications(): Promise<types.VerificationListResponse>;
     getUserVerificationStatus(): Promise<types.UserVerificationStatusResponse>;
     requestReverification(request: types.RequestReverification_req): Promise<types.MessageResponse>;
-    handleWebhook(): Promise<void>;
-    adminBlockUser(request: types.AdminBlockUser_req): Promise<types.MessageResponse>;
-    adminUnblockUser(): Promise<types.MessageResponse>;
-    adminGetUserVerificationStatus(): Promise<types.UserVerificationStatusResponse>;
-    adminGetUserVerifications(): Promise<types.VerificationListResponse>;
+    handleWebhook(params: {
+        provider: string;
+    }): Promise<void>;
+    adminBlockUser(params: {
+        userId: string;
+    }, request: types.AdminBlockUser_req): Promise<types.MessageResponse>;
+    adminUnblockUser(params: {
+        userId: string;
+    }): Promise<types.MessageResponse>;
+    adminGetUserVerificationStatus(params: {
+        userId: string;
+    }): Promise<types.UserVerificationStatusResponse>;
+    adminGetUserVerifications(params: {
+        userId: string;
+    }): Promise<types.VerificationListResponse>;
 }
 export declare function idverificationClient(): IdverificationPlugin;

package/dist/plugins/idverification.js

@@ -16,12 +16,12 @@ class IdverificationPlugin {
             body: request,
         });
     }
-    async getVerificationSession() {
-        const path = '/sessions/:id';
+    async getVerificationSession(params) {
+        const path = `/sessions/${params.id}`;
         return this.client.request('GET', path);
     }
-    async getVerification() {
-        const path = '/:id';
+    async getVerification(params) {
+        const path = `/${params.id}`;
         return this.client.request('GET', path);
     }
     async getUserVerifications() {
@@ -38,26 +38,26 @@ class IdverificationPlugin {
             body: request,
         });
     }
-    async handleWebhook() {
-        const path = '/webhook/:provider';
+    async handleWebhook(params) {
+        const path = `/webhook/${params.provider}`;
         return this.client.request('POST', path);
     }
-    async adminBlockUser(request) {
-        const path = '/users/:userId/block';
+    async adminBlockUser(params, request) {
+        const path = `/users/${params.userId}/block`;
         return this.client.request('POST', path, {
             body: request,
         });
     }
-    async adminUnblockUser() {
-        const path = '/users/:userId/unblock';
+    async adminUnblockUser(params) {
+        const path = `/users/${params.userId}/unblock`;
         return this.client.request('POST', path);
     }
-    async adminGetUserVerificationStatus() {
-        const path = '/users/:userId/status';
+    async adminGetUserVerificationStatus(params) {
+        const path = `/users/${params.userId}/status`;
         return this.client.request('GET', path);
     }
-    async adminGetUserVerifications() {
-        const path = '/users/:userId/verifications';
+    async adminGetUserVerifications(params) {
+        const path = `/users/${params.userId}/verifications`;
         return this.client.request('GET', path);
     }
 }

package/dist/plugins/impersonation.d.ts

@@ -7,7 +7,9 @@ export declare class ImpersonationPlugin implements ClientPlugin {
     init(client: AuthsomeClient): void;
     startImpersonation(request: types.StartImpersonation_reqBody): Promise<void>;
     endImpersonation(request: types.EndImpersonation_reqBody): Promise<void>;
-    getImpersonation(): Promise<void>;
+    getImpersonation(params: {
+        id: string;
+    }): Promise<void>;
     listImpersonations(): Promise<void>;
     listAuditEvents(): Promise<void>;
     verifyImpersonation(): Promise<void>;

package/dist/plugins/impersonation.js

@@ -22,8 +22,8 @@ class ImpersonationPlugin {
             body: request,
         });
     }
-    async getImpersonation() {
-        const path = '/:id';
+    async getImpersonation(params) {
+        const path = `/${params.id}`;
         return this.client.request('GET', path);
     }
     async listImpersonations() {

package/dist/plugins/mfa.d.ts

@@ -7,19 +7,33 @@ export declare class MfaPlugin implements ClientPlugin {
     init(client: AuthsomeClient): void;
     enrollFactor(request: types.FactorEnrollmentRequest): Promise<void>;
     listFactors(): Promise<types.FactorsResponse>;
-    getFactor(): Promise<void>;
-    updateFactor(): Promise<types.MessageResponse>;
-    deleteFactor(): Promise<types.MessageResponse>;
-    verifyFactor(request: types.VerifyFactor_req): Promise<types.MessageResponse>;
+    getFactor(params: {
+        id: string;
+    }): Promise<void>;
+    updateFactor(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
+    deleteFactor(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
+    verifyFactor(params: {
+        id: string;
+    }, request: types.VerifyFactor_req): Promise<types.MessageResponse>;
     initiateChallenge(request: types.ChallengeRequest): Promise<void>;
     verifyChallenge(request: types.VerificationRequest): Promise<void>;
-    getChallengeStatus(): Promise<void>;
+    getChallengeStatus(params: {
+        id: string;
+    }): Promise<void>;
     trustDevice(request: types.DeviceInfo): Promise<types.MessageResponse>;
     listTrustedDevices(): Promise<types.DevicesResponse>;
-    revokeTrustedDevice(): Promise<types.MessageResponse>;
+    revokeTrustedDevice(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
     getStatus(): Promise<void>;
     getPolicy(): Promise<types.MFAConfigResponse>;
     adminUpdatePolicy(request: types.AdminPolicyRequest): Promise<void>;
-    adminResetUserMFA(): Promise<void>;
+    adminResetUserMFA(params: {
+        id: string;
+    }): Promise<void>;
 }
 export declare function mfaClient(): MfaPlugin;

package/dist/plugins/mfa.js

@@ -20,20 +20,20 @@ class MfaPlugin {
         const path = '/mfa/factors';
         return this.client.request('GET', path);
     }
-    async getFactor() {
-        const path = '/mfa/factors/:id';
+    async getFactor(params) {
+        const path = `/mfa/factors/${params.id}`;
         return this.client.request('GET', path);
     }
-    async updateFactor() {
-        const path = '/mfa/factors/:id';
+    async updateFactor(params) {
+        const path = `/mfa/factors/${params.id}`;
         return this.client.request('PUT', path);
     }
-    async deleteFactor() {
-        const path = '/mfa/factors/:id';
+    async deleteFactor(params) {
+        const path = `/mfa/factors/${params.id}`;
         return this.client.request('DELETE', path);
     }
-    async verifyFactor(request) {
-        const path = '/mfa/factors/:id/verify';
+    async verifyFactor(params, request) {
+        const path = `/mfa/factors/${params.id}/verify`;
         return this.client.request('POST', path, {
             body: request,
         });
@@ -50,8 +50,8 @@ class MfaPlugin {
             body: request,
         });
     }
-    async getChallengeStatus() {
-        const path = '/mfa/challenge/:id';
+    async getChallengeStatus(params) {
+        const path = `/mfa/challenge/${params.id}`;
         return this.client.request('GET', path);
     }
     async trustDevice(request) {
@@ -64,8 +64,8 @@ class MfaPlugin {
         const path = '/mfa/devices';
         return this.client.request('GET', path);
     }
-    async revokeTrustedDevice() {
-        const path = '/mfa/devices/:id';
+    async revokeTrustedDevice(params) {
+        const path = `/mfa/devices/${params.id}`;
         return this.client.request('DELETE', path);
     }
     async getStatus() {
@@ -82,8 +82,8 @@ class MfaPlugin {
             body: request,
         });
     }
-    async adminResetUserMFA() {
-        const path = '/mfa/users/:id/reset';
+    async adminResetUserMFA(params) {
+        const path = `/mfa/users/${params.id}/reset`;
         return this.client.request('POST', path);
     }
 }

package/dist/plugins/multiapp.d.ts

@@ -6,23 +6,50 @@ export declare class MultiappPlugin implements ClientPlugin {
     private client;
     init(client: AuthsomeClient): void;
     createApp(): Promise<void>;
-    getApp(): Promise<void>;
-    updateApp(): Promise<void>;
-    deleteApp(): Promise<void>;
+    getApp(params: {
+        appId: string;
+    }): Promise<void>;
+    updateApp(params: {
+        appId: string;
+    }): Promise<void>;
+    deleteApp(params: {
+        appId: string;
+    }): Promise<void>;
     listApps(): Promise<void>;
-    removeMember(): Promise<void>;
+    removeMember(params: {
+        memberId: string;
+    }): Promise<void>;
     listMembers(): Promise<void>;
     inviteMember(): Promise<void>;
-    updateMember(): Promise<void>;
-    getInvitation(): Promise<void>;
-    acceptInvitation(): Promise<void>;
-    declineInvitation(): Promise<void>;
+    updateMember(params: {
+        memberId: string;
+    }): Promise<void>;
+    getInvitation(params: {
+        token: string;
+    }): Promise<void>;
+    acceptInvitation(params: {
+        token: string;
+    }): Promise<void>;
+    declineInvitation(params: {
+        token: string;
+    }): Promise<void>;
     createTeam(): Promise<void>;
-    getTeam(): Promise<void>;
-    updateTeam(): Promise<void>;
-    deleteTeam(): Promise<void>;
+    getTeam(params: {
+        teamId: string;
+    }): Promise<void>;
+    updateTeam(params: {
+        teamId: string;
+    }): Promise<void>;
+    deleteTeam(params: {
+        teamId: string;
+    }): Promise<void>;
     listTeams(): Promise<void>;
-    addTeamMember(request: types.AddTeamMember_req): Promise<void>;
-    removeTeamMember(): Promise<void>;
+    addTeamMember(params: {
+        teamId: string;
+    }, request: types.AddTeamMember_req): Promise<void>;
+    removeTeamMember(params: {
+        teamId: string;
+        memberId: string;
+    }): Promise<void>;
 }
 export declare function multiappClient(): MultiappPlugin;

package/dist/plugins/multiapp.js

@@ -14,24 +14,24 @@ class MultiappPlugin {
         const path = '/createapp';
         return this.client.request('POST', path);
     }
-    async getApp() {
-        const path = '/:appId';
+    async getApp(params) {
+        const path = `/${params.appId}`;
         return this.client.request('GET', path);
     }
-    async updateApp() {
-        const path = '/:appId';
+    async updateApp(params) {
+        const path = `/${params.appId}`;
         return this.client.request('PUT', path);
     }
-    async deleteApp() {
-        const path = '/:appId';
+    async deleteApp(params) {
+        const path = `/${params.appId}`;
         return this.client.request('DELETE', path);
     }
     async listApps() {
         const path = '/listapps';
         return this.client.request('GET', path);
     }
-    async removeMember() {
-        const path = '/:memberId';
+    async removeMember(params) {
+        const path = `/${params.memberId}`;
         return this.client.request('DELETE', path);
     }
     async listMembers() {
@@ -42,50 +42,50 @@ class MultiappPlugin {
         const path = '/invite';
         return this.client.request('POST', path);
     }
-    async updateMember() {
-        const path = '/:memberId';
+    async updateMember(params) {
+        const path = `/${params.memberId}`;
         return this.client.request('PUT', path);
     }
-    async getInvitation() {
-        const path = '/:token';
+    async getInvitation(params) {
+        const path = `/${params.token}`;
         return this.client.request('GET', path);
     }
-    async acceptInvitation() {
-        const path = '/:token/accept';
+    async acceptInvitation(params) {
+        const path = `/${params.token}/accept`;
         return this.client.request('POST', path);
     }
-    async declineInvitation() {
-        const path = '/:token/decline';
+    async declineInvitation(params) {
+        const path = `/${params.token}/decline`;
         return this.client.request('POST', path);
     }
     async createTeam() {
         const path = '/createteam';
         return this.client.request('POST', path);
     }
-    async getTeam() {
-        const path = '/:teamId';
+    async getTeam(params) {
+        const path = `/${params.teamId}`;
         return this.client.request('GET', path);
     }
-    async updateTeam() {
-        const path = '/:teamId';
+    async updateTeam(params) {
+        const path = `/${params.teamId}`;
         return this.client.request('PUT', path);
     }
-    async deleteTeam() {
-        const path = '/:teamId';
+    async deleteTeam(params) {
+        const path = `/${params.teamId}`;
         return this.client.request('DELETE', path);
     }
     async listTeams() {
         const path = '/listteams';
         return this.client.request('GET', path);
     }
-    async addTeamMember(request) {
-        const path = '/:teamId/members';
+    async addTeamMember(params, request) {
+        const path = `/${params.teamId}/members`;
         return this.client.request('POST', path, {
             body: request,
         });
     }
-    async removeTeamMember() {
-        const path = '/:teamId/members/:memberId';
+    async removeTeamMember(params) {
+        const path = `/${params.teamId}/members/${params.memberId}`;
         return this.client.request('DELETE', path);
     }
 }

package/dist/plugins/multisession.d.ts

@@ -7,6 +7,16 @@ export declare class MultisessionPlugin implements ClientPlugin {
     init(client: AuthsomeClient): void;
     list(): Promise<types.SessionsResponse>;
     setActive(request: types.SetActive_body): Promise<types.SessionTokenResponse>;
-    delete(): Promise<types.StatusResponse>;
+    delete(params: {
+        id: string;
+    }): Promise<types.StatusResponse>;
+    getCurrent(): Promise<types.SessionTokenResponse>;
+    getByID(params: {
+        id: string;
+    }): Promise<types.SessionTokenResponse>;
+    revokeAll(request: types.RevokeAll_body): Promise<void>;
+    revokeOthers(): Promise<void>;
+    refresh(): Promise<types.SessionTokenResponse>;
+    getStats(): Promise<void>;
 }
 export declare function multisessionClient(): MultisessionPlugin;

package/dist/plugins/multisession.js

@@ -20,10 +20,36 @@ class MultisessionPlugin {
             body: request,
         });
     }
-    async delete() {
-        const path = '/delete/{id}';
+    async delete(params) {
+        const path = `/delete/${params.id}`;
         return this.client.request('POST', path);
     }
+    async getCurrent() {
+        const path = '/current';
+        return this.client.request('GET', path);
+    }
+    async getByID(params) {
+        const path = `/${params.id}`;
+        return this.client.request('GET', path);
+    }
+    async revokeAll(request) {
+        const path = '/revoke-all';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async revokeOthers() {
+        const path = '/revoke-others';
+        return this.client.request('POST', path);
+    }
+    async refresh() {
+        const path = '/refresh';
+        return this.client.request('POST', path);
+    }
+    async getStats() {
+        const path = '/stats';
+        return this.client.request('GET', path);
+    }
 }
 exports.MultisessionPlugin = MultisessionPlugin;
 function multisessionClient() {

package/dist/plugins/notification.d.ts

@@ -5,20 +5,36 @@ export declare class NotificationPlugin implements ClientPlugin {
     readonly id = "notification";
     private client;
     init(client: AuthsomeClient): void;
-    previewTemplate(request: types.PreviewTemplate_req): Promise<void>;
-    createTemplate(): Promise<void>;
-    getTemplate(): Promise<void>;
+    previewTemplate(params: {
+        id: string;
+    }, request: types.PreviewTemplate_req): Promise<void>;
+    createTemplate(): Promise<types.NotificationTemplateResponse>;
+    getTemplate(params: {
+        id: string;
+    }): Promise<void>;
     listTemplates(): Promise<void>;
-    updateTemplate(): Promise<types.MessageResponse>;
-    deleteTemplate(): Promise<types.MessageResponse>;
-    resetTemplate(): Promise<types.MessageResponse>;
+    updateTemplate(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
+    deleteTemplate(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
+    resetTemplate(params: {
+        id: string;
+    }): Promise<types.MessageResponse>;
     resetAllTemplates(): Promise<types.MessageResponse>;
     getTemplateDefaults(): Promise<void>;
     renderTemplate(request: types.RenderTemplate_req): Promise<void>;
     sendNotification(): Promise<void>;
-    getNotification(): Promise<void>;
+    getNotification(params: {
+        id: string;
+    }): Promise<void>;
     listNotifications(): Promise<void>;
-    resendNotification(): Promise<void>;
-    handleWebhook(): Promise<types.StatusResponse>;
+    resendNotification(params: {
+        id: string;
+    }): Promise<void>;
+    handleWebhook(params: {
+        provider: string;
+    }): Promise<types.StatusResponse>;
 }
 export declare function notificationClient(): NotificationPlugin;