@authsome/client 0.0.4 → 0.0.6

package/dist/plugins/compliance.d.ts

@@ -5,98 +5,98 @@ export declare class CompliancePlugin implements ClientPlugin {
     readonly id = "compliance";
     private client;
     init(client: AuthsomeClient): void;
-    createProfile(request: types.CreateProfileRequest): Promise<void>;
-    createProfileFromTemplate(request: types.CreateProfileFromTemplate_req): Promise<void>;
+    createProfile(request: types.CreateProfileRequest): Promise<types.ComplianceProfileResponse>;
+    createProfileFromTemplate(request: types.CreateProfileFromTemplateRequest): Promise<types.ComplianceProfileResponse>;
     getProfile(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceProfileResponse>;
     getAppProfile(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceProfileResponse>;
     updateProfile(params: {
         id: string;
-    }, request: types.UpdateProfileRequest): Promise<void>;
+    }, request: types.UpdateProfileRequest): Promise<types.ComplianceProfileResponse>;
     deleteProfile(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceStatusResponse>;
     getComplianceStatus(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceStatusDetailsResponse>;
     getDashboard(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceDashboardResponse>;
     runCheck(params: {
         profileId: string;
-    }, request: types.RunCheck_req): Promise<void>;
+    }, request: types.RunCheckRequest): Promise<types.ComplianceCheckResponse>;
     listChecks(params: {
         profileId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceChecksResponse>;
     getCheck(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceCheckResponse>;
     listViolations(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceViolationsResponse>;
     getViolation(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceViolationResponse>;
     resolveViolation(params: {
         id: string;
-    }): Promise<void>;
+    }, request: types.ResolveViolationRequest): Promise<types.ComplianceStatusResponse>;
     generateReport(params: {
         appId: string;
-    }, request: types.GenerateReport_req): Promise<void>;
+    }, request: types.GenerateReportRequest): Promise<types.ComplianceReportResponse>;
     listReports(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceReportsResponse>;
     getReport(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceReportResponse>;
     downloadReport(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceReportFileResponse>;
     createEvidence(params: {
         appId: string;
-    }, request: types.CreateEvidence_req): Promise<void>;
+    }, request: types.CreateEvidenceRequest): Promise<types.ComplianceEvidenceResponse>;
     listEvidence(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceEvidencesResponse>;
     getEvidence(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceEvidenceResponse>;
     deleteEvidence(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceStatusResponse>;
     createPolicy(params: {
         appId: string;
-    }, request: types.CreatePolicy_req): Promise<void>;
+    }, request: types.CreatePolicyRequest): Promise<types.CompliancePolicyResponse>;
     listPolicies(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.CompliancePoliciesResponse>;
     getPolicy(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.CompliancePolicyResponse>;
     updatePolicy(params: {
         id: string;
-    }, request: types.UpdatePolicy_req): Promise<void>;
+    }, request: types.UpdatePolicyRequest): Promise<types.CompliancePolicyResponse>;
     deletePolicy(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceStatusResponse>;
     createTraining(params: {
         appId: string;
-    }, request: types.CreateTraining_req): Promise<void>;
+    }, request: types.CreateTrainingRequest): Promise<types.ComplianceTrainingResponse>;
     listTraining(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceTrainingsResponse>;
     getUserTraining(params: {
         userId: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceUserTrainingResponse>;
     completeTraining(params: {
         id: string;
-    }, request: types.CompleteTraining_req): Promise<void>;
-    listTemplates(): Promise<void>;
+    }, request: types.CompleteTrainingRequest): Promise<types.ComplianceStatusResponse>;
+    listTemplates(): Promise<types.ComplianceTemplatesResponse>;
     getTemplate(params: {
         standard: string;
-    }): Promise<void>;
+    }): Promise<types.ComplianceTemplateResponse>;
 }
 export declare function complianceClient(): CompliancePlugin;

package/dist/plugins/compliance.js

@@ -70,9 +70,11 @@ class CompliancePlugin {
         const path = `/violations/${params.id}`;
         return this.client.request('GET', path);
     }
-    async resolveViolation(params) {
+    async resolveViolation(params, request) {
         const path = `/violations/${params.id}/resolve`;
-        return this.client.request('PUT', path);
+        return this.client.request('PUT', path, {
+            body: request,
+        });
     }
     async generateReport(params, request) {
         const path = `/apps/${params.appId}/reports`;

package/dist/plugins/consent.d.ts

@@ -5,39 +5,39 @@ export declare class ConsentPlugin implements ClientPlugin {
     readonly id = "consent";
     private client;
     init(client: AuthsomeClient): void;
-    createConsent(request: types.CreateConsentRequest): Promise<void>;
+    createConsent(request: types.CreateConsentRequest): Promise<types.ConsentRecordResponse>;
     getConsent(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ConsentRecordResponse>;
     updateConsent(params: {
         id: string;
-    }, request: types.UpdateConsentRequest): Promise<void>;
+    }, request: types.UpdateConsentRequest): Promise<types.ConsentRecordResponse>;
     revokeConsent(params: {
         id: string;
-    }, request: types.UpdateConsentRequest): Promise<types.MessageResponse>;
-    createConsentPolicy(request: types.CreatePolicyRequest): Promise<void>;
+    }, request: types.UpdateConsentRequest): Promise<types.ConsentStatusResponse>;
+    createConsentPolicy(request: types.CreatePolicyRequest): Promise<types.ConsentPolicyResponse>;
     getConsentPolicy(params: {
         id: string;
-    }): Promise<void>;
-    recordCookieConsent(request: types.CookieConsentRequest): Promise<void>;
-    getCookieConsent(): Promise<void>;
-    requestDataExport(request: types.DataExportRequestInput): Promise<void>;
+    }): Promise<types.ConsentPolicyResponse>;
+    recordCookieConsent(request: types.CookieConsentRequest): Promise<types.ConsentCookieResponse>;
+    getCookieConsent(): Promise<types.ConsentCookieResponse>;
+    requestDataExport(request: types.DataExportRequestInput): Promise<types.ConsentExportResponse>;
     getDataExport(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ConsentExportResponse>;
     downloadDataExport(params: {
         id: string;
-    }): Promise<void>;
-    requestDataDeletion(request: types.DataDeletionRequestInput): Promise<void>;
+    }): Promise<types.ConsentExportFileResponse>;
+    requestDataDeletion(request: types.DataDeletionRequestInput): Promise<types.ConsentDeletionResponse>;
     getDataDeletion(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ConsentDeletionResponse>;
     approveDeletionRequest(params: {
         id: string;
-    }): Promise<types.MessageResponse>;
-    getPrivacySettings(): Promise<void>;
-    updatePrivacySettings(request: types.PrivacySettingsRequest): Promise<void>;
-    getConsentAuditLogs(): Promise<void>;
-    generateConsentReport(): Promise<void>;
+    }): Promise<types.ConsentStatusResponse>;
+    getPrivacySettings(): Promise<types.ConsentSettingsResponse>;
+    updatePrivacySettings(request: types.PrivacySettingsRequest): Promise<types.ConsentSettingsResponse>;
+    getConsentAuditLogs(): Promise<types.ConsentAuditLogsResponse>;
+    generateConsentReport(): Promise<types.ConsentReportResponse>;
 }
 export declare function consentClient(): ConsentPlugin;

package/dist/plugins/emailverification.d.ts

@@ -5,8 +5,8 @@ export declare class EmailverificationPlugin implements ClientPlugin {
     readonly id = "emailverification";
     private client;
     init(client: AuthsomeClient): void;
-    send(request: types.SendRequest): Promise<void>;
-    verify(): Promise<void>;
+    send(request: types.SendRequest): Promise<types.SendResponse>;
+    verify(request?: types.VerifyRequest): Promise<types.VerifyResponse>;
     resend(request: types.ResendRequest): Promise<types.ResendResponse>;
 }
 export declare function emailverificationClient(): EmailverificationPlugin;

package/dist/plugins/emailverification.js

@@ -16,9 +16,11 @@ class EmailverificationPlugin {
             body: request,
         });
     }
-    async verify() {
+    async verify(request) {
         const path = '/email-verification/verify';
-        return this.client.request('GET', path);
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
     }
     async resend(request) {
         const path = '/email-verification/resend';

package/dist/plugins/idverification.d.ts

@@ -5,30 +5,30 @@ export declare class IdverificationPlugin implements ClientPlugin {
     readonly id = "idverification";
     private client;
     init(client: AuthsomeClient): void;
-    createVerificationSession(request: types.CreateVerificationSession_req): Promise<types.VerificationSessionResponse>;
+    createVerificationSession(request: types.CreateVerificationSession_req): Promise<types.IDVerificationSessionResponse>;
     getVerificationSession(params: {
         id: string;
-    }): Promise<types.VerificationSessionResponse>;
+    }): Promise<types.IDVerificationSessionResponse>;
     getVerification(params: {
         id: string;
-    }): Promise<types.VerificationResponse>;
-    getUserVerifications(): Promise<types.VerificationListResponse>;
-    getUserVerificationStatus(): Promise<types.UserVerificationStatusResponse>;
-    requestReverification(request: types.RequestReverification_req): Promise<types.MessageResponse>;
+    }): Promise<types.IDVerificationResponse>;
+    getUserVerifications(): Promise<types.IDVerificationListResponse>;
+    getUserVerificationStatus(): Promise<types.IDVerificationStatusResponse>;
+    requestReverification(request: types.RequestReverification_req): Promise<types.IDVerificationSessionResponse>;
     handleWebhook(params: {
         provider: string;
-    }): Promise<void>;
+    }): Promise<types.IDVerificationWebhookResponse>;
     adminBlockUser(params: {
         userId: string;
-    }, request: types.AdminBlockUser_req): Promise<types.MessageResponse>;
+    }, request: types.AdminBlockUser_req): Promise<types.IDVerificationStatusResponse>;
     adminUnblockUser(params: {
         userId: string;
-    }): Promise<types.MessageResponse>;
+    }): Promise<types.IDVerificationStatusResponse>;
     adminGetUserVerificationStatus(params: {
         userId: string;
-    }): Promise<types.UserVerificationStatusResponse>;
+    }): Promise<types.IDVerificationStatusResponse>;
     adminGetUserVerifications(params: {
         userId: string;
-    }): Promise<types.VerificationListResponse>;
+    }): Promise<types.IDVerificationListResponse>;
 }
 export declare function idverificationClient(): IdverificationPlugin;

package/dist/plugins/idverification.js

@@ -11,53 +11,53 @@ class IdverificationPlugin {
         this.client = client;
     }
     async createVerificationSession(request) {
-        const path = '/sessions';
+        const path = '/verification/sessions';
         return this.client.request('POST', path, {
             body: request,
         });
     }
     async getVerificationSession(params) {
-        const path = `/sessions/${params.id}`;
+        const path = `/verification/sessions/${params.id}`;
         return this.client.request('GET', path);
     }
     async getVerification(params) {
-        const path = `/${params.id}`;
+        const path = `/verification/${params.id}`;
         return this.client.request('GET', path);
     }
     async getUserVerifications() {
-        const path = '/me';
+        const path = '/verification/me';
         return this.client.request('GET', path);
     }
     async getUserVerificationStatus() {
-        const path = '/me/status';
+        const path = '/verification/me/status';
         return this.client.request('GET', path);
     }
     async requestReverification(request) {
-        const path = '/me/reverify';
+        const path = '/verification/me/reverify';
         return this.client.request('POST', path, {
             body: request,
         });
     }
     async handleWebhook(params) {
-        const path = `/webhook/${params.provider}`;
+        const path = `/verification/webhook/${params.provider}`;
         return this.client.request('POST', path);
     }
     async adminBlockUser(params, request) {
-        const path = `/users/${params.userId}/block`;
+        const path = `/verification/users/${params.userId}/block`;
         return this.client.request('POST', path, {
             body: request,
         });
     }
     async adminUnblockUser(params) {
-        const path = `/users/${params.userId}/unblock`;
+        const path = `/verification/users/${params.userId}/unblock`;
         return this.client.request('POST', path);
     }
     async adminGetUserVerificationStatus(params) {
-        const path = `/users/${params.userId}/status`;
+        const path = `/verification/users/${params.userId}/status`;
         return this.client.request('GET', path);
     }
     async adminGetUserVerifications(params) {
-        const path = `/users/${params.userId}/verifications`;
+        const path = `/verification/users/${params.userId}/verifications`;
         return this.client.request('GET', path);
     }
 }

package/dist/plugins/impersonation.d.ts

@@ -5,13 +5,13 @@ export declare class ImpersonationPlugin implements ClientPlugin {
     readonly id = "impersonation";
     private client;
     init(client: AuthsomeClient): void;
-    startImpersonation(request: types.StartImpersonation_reqBody): Promise<void>;
-    endImpersonation(request: types.EndImpersonation_reqBody): Promise<void>;
+    startImpersonation(): Promise<types.ImpersonationStartResponse>;
+    endImpersonation(): Promise<types.ImpersonationEndResponse>;
     getImpersonation(params: {
         id: string;
-    }): Promise<void>;
-    listImpersonations(): Promise<void>;
-    listAuditEvents(): Promise<void>;
-    verifyImpersonation(): Promise<void>;
+    }): Promise<types.ImpersonationSession>;
+    listImpersonations(): Promise<types.ImpersonationListResponse>;
+    listAuditEvents(): Promise<types.ImpersonationAuditResponse>;
+    verifyImpersonation(): Promise<types.ImpersonationVerifyResponse>;
 }
 export declare function impersonationClient(): ImpersonationPlugin;

package/dist/plugins/impersonation.js

@@ -10,32 +10,28 @@ class ImpersonationPlugin {
     init(client) {
         this.client = client;
     }
-    async startImpersonation(request) {
-        const path = '/start';
-        return this.client.request('POST', path, {
-            body: request,
-        });
-    }
-    async endImpersonation(request) {
-        const path = '/end';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+    async startImpersonation() {
+        const path = '/impersonation/start';
+        return this.client.request('POST', path);
+    }
+    async endImpersonation() {
+        const path = '/impersonation/end';
+        return this.client.request('POST', path);
     }
     async getImpersonation(params) {
-        const path = `/${params.id}`;
+        const path = `/impersonation/${params.id}`;
         return this.client.request('GET', path);
     }
     async listImpersonations() {
-        const path = '/';
+        const path = '/impersonation/';
         return this.client.request('GET', path);
     }
     async listAuditEvents() {
-        const path = '/audit';
+        const path = '/impersonation/audit';
         return this.client.request('GET', path);
     }
     async verifyImpersonation() {
-        const path = '/verify';
+        const path = '/impersonation/verify';
         return this.client.request('POST', path);
     }
 }

package/dist/plugins/jwt.d.ts

@@ -1,13 +1,14 @@
 import { ClientPlugin } from '../plugin';
 import { AuthsomeClient } from '../client';
+import * as types from '../types';
 export declare class JwtPlugin implements ClientPlugin {
     readonly id = "jwt";
     private client;
     init(client: AuthsomeClient): void;
-    createJWTKey(): Promise<void>;
-    listJWTKeys(): Promise<void>;
-    getJWKS(): Promise<void>;
-    generateToken(): Promise<void>;
-    verifyToken(): Promise<void>;
+    createJWTKey(request: types.CreateJWTKeyRequest): Promise<types.JWTKey>;
+    listJWTKeys(request?: types.ListJWTKeysRequest): Promise<types.ListJWTKeysResponse>;
+    getJWKS(): Promise<types.JWKSResponse>;
+    generateToken(request: types.GenerateTokenRequest): Promise<types.GenerateTokenResponse>;
+    verifyToken(request: types.VerifyTokenRequest): Promise<types.VerifyTokenResponse>;
 }
 export declare function jwtClient(): JwtPlugin;

package/dist/plugins/jwt.js

@@ -10,25 +10,33 @@ class JwtPlugin {
     init(client) {
         this.client = client;
     }
-    async createJWTKey() {
-        const path = '/createjwtkey';
-        return this.client.request('POST', path);
+    async createJWTKey(request) {
+        const path = '/jwt/createjwtkey';
+        return this.client.request('POST', path, {
+            body: request,
+        });
     }
-    async listJWTKeys() {
-        const path = '/listjwtkeys';
-        return this.client.request('GET', path);
+    async listJWTKeys(request) {
+        const path = '/jwt/listjwtkeys';
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
     }
     async getJWKS() {
-        const path = '/jwks';
+        const path = '/jwt/jwks';
         return this.client.request('GET', path);
     }
-    async generateToken() {
-        const path = '/generate';
-        return this.client.request('POST', path);
+    async generateToken(request) {
+        const path = '/jwt/generate';
+        return this.client.request('POST', path, {
+            body: request,
+        });
     }
-    async verifyToken() {
-        const path = '/verify';
-        return this.client.request('POST', path);
+    async verifyToken(request) {
+        const path = '/jwt/verify';
+        return this.client.request('POST', path, {
+            body: request,
+        });
     }
 }
 exports.JwtPlugin = JwtPlugin;

package/dist/plugins/mfa.d.ts

@@ -5,11 +5,11 @@ export declare class MfaPlugin implements ClientPlugin {
     readonly id = "mfa";
     private client;
     init(client: AuthsomeClient): void;
-    enrollFactor(request: types.FactorEnrollmentRequest): Promise<void>;
+    enrollFactor(request: types.FactorEnrollmentRequest): Promise<types.FactorEnrollmentResponse>;
     listFactors(): Promise<types.FactorsResponse>;
     getFactor(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.Factor>;
     updateFactor(params: {
         id: string;
     }): Promise<types.MessageResponse>;
@@ -18,22 +18,22 @@ export declare class MfaPlugin implements ClientPlugin {
     }): 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>;
+    }): Promise<types.MessageResponse>;
+    initiateChallenge(request: types.ChallengeRequest): Promise<types.ChallengeResponse>;
+    verifyChallenge(request: types.VerificationRequest): Promise<types.VerificationResponse>;
     getChallengeStatus(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.ChallengeStatusResponse>;
     trustDevice(request: types.DeviceInfo): Promise<types.MessageResponse>;
     listTrustedDevices(): Promise<types.DevicesResponse>;
     revokeTrustedDevice(params: {
         id: string;
     }): Promise<types.MessageResponse>;
-    getStatus(): Promise<void>;
+    getStatus(): Promise<types.MFAStatus>;
     getPolicy(): Promise<types.MFAConfigResponse>;
-    adminUpdatePolicy(request: types.AdminPolicyRequest): Promise<void>;
+    adminUpdatePolicy(): Promise<types.StatusResponse>;
     adminResetUserMFA(params: {
         id: string;
-    }): Promise<void>;
+    }): Promise<types.MessageResponse>;
 }
 export declare function mfaClient(): MfaPlugin;

package/dist/plugins/mfa.js

@@ -32,11 +32,9 @@ class MfaPlugin {
         const path = `/mfa/factors/${params.id}`;
         return this.client.request('DELETE', path);
     }
-    async verifyFactor(params, request) {
+    async verifyFactor(params) {
         const path = `/mfa/factors/${params.id}/verify`;
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
     async initiateChallenge(request) {
         const path = '/mfa/challenge';
@@ -76,11 +74,9 @@ class MfaPlugin {
         const path = '/mfa/policy';
         return this.client.request('GET', path);
     }
-    async adminUpdatePolicy(request) {
+    async adminUpdatePolicy() {
         const path = '/mfa/policy';
-        return this.client.request('PUT', path, {
-            body: request,
-        });
+        return this.client.request('PUT', path);
     }
     async adminResetUserMFA(params) {
         const path = `/mfa/users/${params.id}/reset`;

package/dist/plugins/multiapp.d.ts

@@ -5,51 +5,51 @@ export declare class MultiappPlugin implements ClientPlugin {
     readonly id = "multiapp";
     private client;
     init(client: AuthsomeClient): void;
-    createApp(): Promise<void>;
+    createApp(): Promise<types.App>;
     getApp(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.App>;
     updateApp(params: {
         appId: string;
-    }): Promise<void>;
+    }): Promise<types.App>;
     deleteApp(params: {
         appId: string;
-    }): Promise<void>;
-    listApps(): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
+    listApps(): Promise<types.AppsListResponse>;
     removeMember(params: {
         memberId: string;
-    }): Promise<void>;
-    listMembers(): Promise<void>;
-    inviteMember(): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
+    listMembers(): Promise<types.MembersListResponse>;
+    inviteMember(request: types.InviteMemberRequest): Promise<types.Invitation>;
     updateMember(params: {
         memberId: string;
-    }): Promise<void>;
+    }, request: types.UpdateMemberRequest): Promise<types.Member>;
     getInvitation(params: {
         token: string;
-    }): Promise<void>;
+    }): Promise<types.Invitation>;
     acceptInvitation(params: {
         token: string;
-    }): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
     declineInvitation(params: {
         token: string;
-    }): Promise<void>;
-    createTeam(): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
+    createTeam(request: types.CreateTeamRequest): Promise<types.Team>;
     getTeam(params: {
         teamId: string;
-    }): Promise<void>;
+    }): Promise<types.Team>;
     updateTeam(params: {
         teamId: string;
-    }): Promise<void>;
+    }, request: types.UpdateTeamRequest): Promise<types.Team>;
     deleteTeam(params: {
         teamId: string;
-    }): Promise<void>;
-    listTeams(): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
+    listTeams(): Promise<types.TeamsListResponse>;
     addTeamMember(params: {
         teamId: string;
-    }, request: types.AddTeamMember_req): Promise<void>;
+    }, request: types.AddTeamMember_req): Promise<types.MultitenancyStatusResponse>;
     removeTeamMember(params: {
         teamId: string;
         memberId: string;
-    }): Promise<void>;
+    }): Promise<types.MultitenancyStatusResponse>;
 }
 export declare function multiappClient(): MultiappPlugin;