@authsome/client 0.0.3 → 0.0.5

package/dist/plugins/organization.js

@@ -14,60 +14,60 @@ class OrganizationPlugin {
         const path = '/createorganization';
         return this.client.request('POST', path);
     }
-    async updateOrganization() {
-        const path = '/:id';
+    async updateOrganization(params) {
+        const path = `/${params.id}`;
         return this.client.request('PATCH', path);
     }
-    async deleteOrganization() {
-        const path = '/:id';
+    async deleteOrganization(params) {
+        const path = `/${params.id}`;
         return this.client.request('DELETE', path);
     }
     async inviteMember() {
         const path = '/invite';
         return this.client.request('POST', path);
     }
-    async removeMember() {
-        const path = '/:memberId';
+    async removeMember(params) {
+        const path = `/${params.memberId}`;
         return this.client.request('DELETE', path);
     }
     async createTeam() {
         const path = '/createteam';
         return this.client.request('POST', path);
     }
-    async updateTeam() {
-        const path = '/:teamId';
+    async updateTeam(params) {
+        const path = `/${params.teamId}`;
         return this.client.request('PATCH', path);
     }
-    async deleteTeam() {
-        const path = '/:teamId';
+    async deleteTeam(params) {
+        const path = `/${params.teamId}`;
         return this.client.request('DELETE', path);
     }
-    async getOrganization() {
-        const path = '/:id';
+    async getOrganization(params) {
+        const path = `/${params.id}`;
         return this.client.request('GET', path);
     }
     async listOrganizations() {
         const path = '/listorganizations';
         return this.client.request('GET', path);
     }
-    async getOrganizationBySlug() {
-        const path = '/slug/:slug';
+    async getOrganizationBySlug(params) {
+        const path = `/slug/${params.slug}`;
         return this.client.request('GET', path);
     }
     async listMembers() {
         const path = '/listmembers';
         return this.client.request('GET', path);
     }
-    async updateMember() {
-        const path = '/:memberId';
+    async updateMember(params) {
+        const path = `/${params.memberId}`;
         return this.client.request('PATCH', 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 listTeams() {

package/dist/plugins/passkey.d.ts

@@ -10,7 +10,11 @@ export declare class PasskeyPlugin implements ClientPlugin {
     beginLogin(): Promise<void>;
     finishLogin(): Promise<void>;
     list(): Promise<void>;
-    update(): Promise<void>;
-    delete(): Promise<types.StatusResponse>;
+    update(params: {
+        id: string;
+    }): Promise<void>;
+    delete(params: {
+        id: string;
+    }): Promise<types.StatusResponse>;
 }
 export declare function passkeyClient(): PasskeyPlugin;

package/dist/plugins/passkey.js

@@ -30,12 +30,12 @@ class PasskeyPlugin {
         const path = '/list';
         return this.client.request('GET', path);
     }
-    async update() {
-        const path = '/:id';
+    async update(params) {
+        const path = `/${params.id}`;
         return this.client.request('PUT', path);
     }
-    async delete() {
-        const path = '/:id';
+    async delete(params) {
+        const path = `/${params.id}`;
         return this.client.request('DELETE', path);
     }
 }

package/dist/plugins/permissions.d.ts

@@ -0,0 +1,12 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class PermissionsPlugin implements ClientPlugin {
+    readonly id = "permissions";
+    private client;
+    init(client: AuthsomeClient): void;
+    migrateAll(request: types.MigrateAllRequest): Promise<types.ErrorResponse>;
+    migrateRoles(): Promise<types.ErrorResponse>;
+    previewConversion(request: types.PreviewConversionRequest): Promise<types.ErrorResponse>;
+}
+export declare function permissionsClient(): PermissionsPlugin;

package/dist/plugins/permissions.js

@@ -0,0 +1,33 @@
+"use strict";
+// Auto-generated permissions plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsPlugin = void 0;
+exports.permissionsClient = permissionsClient;
+class PermissionsPlugin {
+    constructor() {
+        this.id = 'permissions';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async migrateAll(request) {
+        const path = '/migrate/all';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async migrateRoles() {
+        const path = '/migrate/roles';
+        return this.client.request('POST', path);
+    }
+    async previewConversion(request) {
+        const path = '/migrate/preview';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+}
+exports.PermissionsPlugin = PermissionsPlugin;
+function permissionsClient() {
+    return new PermissionsPlugin();
+}

package/dist/plugins/secrets.d.ts

@@ -0,0 +1,33 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class SecretsPlugin implements ClientPlugin {
+    readonly id = "secrets";
+    private client;
+    init(client: AuthsomeClient): void;
+    list(request?: types.ListSecretsRequest): Promise<types.ListSecretsResponse>;
+    create(request: types.CreateSecretRequest): Promise<types.SecretDTO>;
+    get(params: {
+        id: string;
+    }, request?: types.GetSecretRequest): Promise<types.SecretDTO>;
+    getValue(params: {
+        id: string;
+    }, request?: types.GetValueRequest): Promise<types.RevealValueResponse>;
+    update(params: {
+        id: string;
+    }, request: types.UpdateSecretRequest): Promise<types.SecretDTO>;
+    delete(params: {
+        id: string;
+    }, request?: types.DeleteSecretRequest): Promise<types.SuccessResponse>;
+    getByPath(): Promise<types.ErrorResponse>;
+    getVersions(params: {
+        id: string;
+    }, request?: types.GetVersionsRequest): Promise<types.ListVersionsResponse>;
+    rollback(params: {
+        id: string;
+        version: number;
+    }, request: types.RollbackRequest): Promise<types.SecretDTO>;
+    getStats(): Promise<types.StatsDTO>;
+    getTree(request?: types.GetTreeRequest): Promise<types.SecretTreeNode>;
+}
+export declare function secretsClient(): SecretsPlugin;

package/dist/plugins/secrets.js

@@ -0,0 +1,79 @@
+"use strict";
+// Auto-generated secrets plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretsPlugin = void 0;
+exports.secretsClient = secretsClient;
+class SecretsPlugin {
+    constructor() {
+        this.id = 'secrets';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async list(request) {
+        const path = '/list';
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+    async create(request) {
+        const path = '/create';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async get(params, request) {
+        const path = `/${params.id}`;
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+    async getValue(params, request) {
+        const path = `/${params.id}/value`;
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+    async update(params, request) {
+        const path = `/${params.id}`;
+        return this.client.request('PUT', path, {
+            body: request,
+        });
+    }
+    async delete(params, request) {
+        const path = `/${params.id}`;
+        return this.client.request('DELETE', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+    async getByPath() {
+        const path = '/path/*path';
+        return this.client.request('GET', path);
+    }
+    async getVersions(params, request) {
+        const path = `/${params.id}/versions`;
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+    async rollback(params, request) {
+        const path = `/${params.id}/rollback/${params.version}`;
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async getStats() {
+        const path = '/stats';
+        return this.client.request('GET', path);
+    }
+    async getTree(request) {
+        const path = '/tree';
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(request),
+        });
+    }
+}
+exports.SecretsPlugin = SecretsPlugin;
+function secretsClient() {
+    return new SecretsPlugin();
+}

package/dist/plugins/social.d.ts

@@ -6,9 +6,18 @@ export declare class SocialPlugin implements ClientPlugin {
     private client;
     init(client: AuthsomeClient): void;
     signIn(request: types.SignInRequest): Promise<types.AuthURLResponse>;
-    callback(): Promise<types.CallbackDataResponse>;
+    callback(params: {
+        provider: string;
+    }, query?: {
+        state?: string;
+        code?: string;
+        error?: string;
+        errorDescription?: string;
+    }): Promise<types.CallbackDataResponse>;
     linkAccount(request: types.LinkAccountRequest): Promise<types.AuthURLResponse>;
-    unlinkAccount(): Promise<types.MessageResponse>;
+    unlinkAccount(params: {
+        provider: string;
+    }): Promise<types.MessageResponse>;
     listProviders(): Promise<types.ProvidersResponse>;
 }
 export declare function socialClient(): SocialPlugin;

package/dist/plugins/social.js

@@ -16,9 +16,11 @@ class SocialPlugin {
             body: request,
         });
     }
-    async callback() {
-        const path = '/callback/:provider';
-        return this.client.request('GET', path);
+    async callback(params, query) {
+        const path = `/callback/${params.provider}`;
+        return this.client.request('GET', path, {
+            query: this.client.toQueryParams(query),
+        });
     }
     async linkAccount(request) {
         const path = '/account/link';
@@ -26,8 +28,8 @@ class SocialPlugin {
             body: request,
         });
     }
-    async unlinkAccount() {
-        const path = '/account/unlink/:provider';
+    async unlinkAccount(params) {
+        const path = `/account/unlink/${params.provider}`;
         return this.client.request('DELETE', path);
     }
     async listProviders() {

package/dist/plugins/sso.d.ts

@@ -7,9 +7,17 @@ export declare class SsoPlugin implements ClientPlugin {
     init(client: AuthsomeClient): void;
     registerProvider(request: types.RegisterProviderRequest): Promise<types.ProviderRegisteredResponse>;
     sAMLSPMetadata(): Promise<types.MetadataResponse>;
-    sAMLLogin(request: types.SAMLLoginRequest): Promise<types.SAMLLoginResponse>;
-    sAMLCallback(): Promise<types.SSOAuthResponse>;
-    oIDCLogin(request: types.OIDCLoginRequest): Promise<types.OIDCLoginResponse>;
-    oIDCCallback(): Promise<types.SSOAuthResponse>;
+    sAMLLogin(params: {
+        providerId: string;
+    }, request: types.SAMLLoginRequest): Promise<types.SAMLLoginResponse>;
+    sAMLCallback(params: {
+        providerId: string;
+    }): Promise<types.SSOAuthResponse>;
+    oIDCLogin(params: {
+        providerId: string;
+    }, request: types.OIDCLoginRequest): Promise<types.OIDCLoginResponse>;
+    oIDCCallback(params: {
+        providerId: string;
+    }): Promise<types.SSOAuthResponse>;
 }
 export declare function ssoClient(): SsoPlugin;

package/dist/plugins/sso.js

@@ -20,24 +20,24 @@ class SsoPlugin {
         const path = '/saml2/sp/metadata';
         return this.client.request('GET', path);
     }
-    async sAMLLogin(request) {
-        const path = '/saml2/login/:providerId';
+    async sAMLLogin(params, request) {
+        const path = `/saml2/login/${params.providerId}`;
         return this.client.request('POST', path, {
             body: request,
         });
     }
-    async sAMLCallback() {
-        const path = '/saml2/callback/:providerId';
+    async sAMLCallback(params) {
+        const path = `/saml2/callback/${params.providerId}`;
         return this.client.request('POST', path);
     }
-    async oIDCLogin(request) {
-        const path = '/oidc/login/:providerId';
+    async oIDCLogin(params, request) {
+        const path = `/oidc/login/${params.providerId}`;
         return this.client.request('POST', path, {
             body: request,
         });
     }
-    async oIDCCallback() {
-        const path = '/oidc/callback/:providerId';
+    async oIDCCallback(params) {
+        const path = `/oidc/callback/${params.providerId}`;
         return this.client.request('GET', path);
     }
 }

package/dist/plugins/stepup.d.ts

@@ -5,19 +5,29 @@ export declare class StepupPlugin implements ClientPlugin {
     readonly id = "stepup";
     private client;
     init(client: AuthsomeClient): void;
-    evaluate(request: types.EvaluateRequest): Promise<void>;
-    verify(request: types.VerifyRequest): Promise<void>;
-    getRequirement(): Promise<void>;
-    listPendingRequirements(): Promise<types.RequirementsResponse>;
-    listVerifications(): Promise<void>;
+    evaluate(request: types.EvaluateRequest): Promise<types.StepUpEvaluationResponse>;
+    verify(request: types.VerifyRequest): Promise<types.StepUpVerificationResponse>;
+    getRequirement(params: {
+        id: string;
+    }): Promise<types.StepUpRequirementResponse>;
+    listPendingRequirements(): Promise<types.StepUpRequirementsResponse>;
+    listVerifications(): Promise<types.StepUpVerificationsResponse>;
     listRememberedDevices(): Promise<types.StepUpDevicesResponse>;
-    forgetDevice(): Promise<types.ForgetDeviceResponse>;
-    createPolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicy>;
-    listPolicies(): Promise<void>;
-    getPolicy(): Promise<void>;
-    updatePolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicy>;
-    deletePolicy(): Promise<void>;
-    getAuditLogs(): Promise<void>;
-    status(): Promise<void>;
+    forgetDevice(params: {
+        id: string;
+    }): Promise<types.StepUpStatusResponse>;
+    createPolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicyResponse>;
+    listPolicies(): Promise<types.StepUpPoliciesResponse>;
+    getPolicy(params: {
+        id: string;
+    }): Promise<types.StepUpPolicyResponse>;
+    updatePolicy(params: {
+        id: string;
+    }, request: types.StepUpPolicy): Promise<types.StepUpPolicyResponse>;
+    deletePolicy(params: {
+        id: string;
+    }): Promise<types.StepUpStatusResponse>;
+    getAuditLogs(): Promise<types.StepUpAuditLogsResponse>;
+    status(): Promise<types.StepUpStatusResponse>;
 }
 export declare function stepupClient(): StepupPlugin;

package/dist/plugins/stepup.js

@@ -22,8 +22,8 @@ class StepupPlugin {
             body: request,
         });
     }
-    async getRequirement() {
-        const path = '/requirements/:id';
+    async getRequirement(params) {
+        const path = `/requirements/${params.id}`;
         return this.client.request('GET', path);
     }
     async listPendingRequirements() {
@@ -38,8 +38,8 @@ class StepupPlugin {
         const path = '/devices';
         return this.client.request('GET', path);
     }
-    async forgetDevice() {
-        const path = '/devices/:id';
+    async forgetDevice(params) {
+        const path = `/devices/${params.id}`;
         return this.client.request('DELETE', path);
     }
     async createPolicy(request) {
@@ -52,18 +52,18 @@ class StepupPlugin {
         const path = '/policies';
         return this.client.request('GET', path);
     }
-    async getPolicy() {
-        const path = '/policies/:id';
+    async getPolicy(params) {
+        const path = `/policies/${params.id}`;
         return this.client.request('GET', path);
     }
-    async updatePolicy(request) {
-        const path = '/policies/:id';
+    async updatePolicy(params, request) {
+        const path = `/policies/${params.id}`;
         return this.client.request('PUT', path, {
             body: request,
         });
     }
-    async deletePolicy() {
-        const path = '/policies/:id';
+    async deletePolicy(params) {
+        const path = `/policies/${params.id}`;
         return this.client.request('DELETE', path);
     }
     async getAuditLogs() {

package/dist/plugins/twofa.d.ts

@@ -5,11 +5,11 @@ export declare class TwofaPlugin implements ClientPlugin {
     readonly id = "twofa";
     private client;
     init(client: AuthsomeClient): void;
-    enable(request: types.Enable_body): Promise<void>;
-    verify(request: types.Verify_body): Promise<types.StatusResponse>;
-    disable(request: types.Disable_body): Promise<types.StatusResponse>;
-    generateBackupCodes(request: types.GenerateBackupCodes_body): Promise<types.CodesResponse>;
-    sendOTP(request: types.SendOTP_body): Promise<types.OTPSentResponse>;
-    status(request: types.Status_body): Promise<types.TwoFAStatusResponse>;
+    enable(): Promise<void>;
+    verify(): Promise<types.StatusResponse>;
+    disable(): Promise<types.StatusResponse>;
+    generateBackupCodes(): Promise<types.CodesResponse>;
+    sendOTP(): Promise<types.OTPSentResponse>;
+    status(): Promise<types.TwoFAStatusResponse>;
 }
 export declare function twofaClient(): TwofaPlugin;

package/dist/plugins/twofa.js

@@ -10,41 +10,29 @@ class TwofaPlugin {
     init(client) {
         this.client = client;
     }
-    async enable(request) {
+    async enable() {
         const path = '/2fa/enable';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
-    async verify(request) {
+    async verify() {
         const path = '/2fa/verify';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
-    async disable(request) {
+    async disable() {
         const path = '/2fa/disable';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
-    async generateBackupCodes(request) {
+    async generateBackupCodes() {
         const path = '/2fa/generate-backup-codes';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
-    async sendOTP(request) {
+    async sendOTP() {
         const path = '/2fa/send-otp';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
-    async status(request) {
+    async status() {
         const path = '/2fa/status';
-        return this.client.request('POST', path, {
-            body: request,
-        });
+        return this.client.request('POST', path);
     }
 }
 exports.TwofaPlugin = TwofaPlugin;

package/dist/plugins/username.d.ts

@@ -5,7 +5,7 @@ export declare class UsernamePlugin implements ClientPlugin {
     readonly id = "username";
     private client;
     init(client: AuthsomeClient): void;
-    signUp(): Promise<types.SignUpResponse>;
-    signIn(): Promise<types.SignInResponse>;
+    signUp(request: types.SignUpRequest): Promise<types.SignUpResponse>;
+    signIn(request: types.SignInRequest): Promise<types.TwoFARequiredResponse>;
 }
 export declare function usernameClient(): UsernamePlugin;

package/dist/plugins/username.js

@@ -10,13 +10,17 @@ class UsernamePlugin {
     init(client) {
         this.client = client;
     }
-    async signUp() {
+    async signUp(request) {
         const path = '/username/signup';
-        return this.client.request('POST', path);
+        return this.client.request('POST', path, {
+            body: request,
+        });
     }
-    async signIn() {
+    async signIn(request) {
         const path = '/username/signin';
-        return this.client.request('POST', path);
+        return this.client.request('POST', path, {
+            body: request,
+        });
     }
 }
 exports.UsernamePlugin = UsernamePlugin;