@authsome/client 0.0.4 → 0.0.6

package/src/plugins/organization.ts

@@ -12,83 +12,83 @@ export class OrganizationPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async createOrganization(): Promise<void> {
-    const path = '/createorganization';
-    return this.client.request<void>('POST', path);
+  async createOrganization(): Promise<types.Organization> {
+    const path = '/organizations/createorganization';
+    return this.client.request<types.Organization>('POST', path);
   }
 
-  async updateOrganization(params: { id: string }): Promise<void> {
-    const path = `/${params.id}`;
-    return this.client.request<void>('PATCH', path);
+  async updateOrganization(params: { id: string }): Promise<types.Organization> {
+    const path = `/organizations/${params.id}`;
+    return this.client.request<types.Organization>('PATCH', path);
   }
 
   async deleteOrganization(params: { id: string }): Promise<void> {
-    const path = `/${params.id}`;
+    const path = `/organizations/${params.id}`;
     return this.client.request<void>('DELETE', path);
   }
 
   async inviteMember(): Promise<void> {
-    const path = '/invite';
+    const path = '/organizations/invite';
     return this.client.request<void>('POST', path);
   }
 
   async removeMember(params: { memberId: string }): Promise<void> {
-    const path = `/${params.memberId}`;
+    const path = `/organizations/${params.memberId}`;
     return this.client.request<void>('DELETE', path);
   }
 
   async createTeam(): Promise<void> {
-    const path = '/createteam';
+    const path = '/organizations/createteam';
     return this.client.request<void>('POST', path);
   }
 
   async updateTeam(params: { teamId: string }): Promise<void> {
-    const path = `/${params.teamId}`;
+    const path = `/organizations/${params.teamId}`;
     return this.client.request<void>('PATCH', path);
   }
 
   async deleteTeam(params: { teamId: string }): Promise<void> {
-    const path = `/${params.teamId}`;
+    const path = `/organizations/${params.teamId}`;
     return this.client.request<void>('DELETE', path);
   }
 
-  async getOrganization(params: { id: string }): Promise<void> {
-    const path = `/${params.id}`;
-    return this.client.request<void>('GET', path);
+  async getOrganization(params: { id: string }): Promise<types.Organization> {
+    const path = `/organizations/${params.id}`;
+    return this.client.request<types.Organization>('GET', path);
   }
 
-  async listOrganizations(): Promise<void> {
-    const path = '/listorganizations';
-    return this.client.request<void>('GET', path);
+  async listOrganizations(): Promise<types.Organization> {
+    const path = '/organizations/listorganizations';
+    return this.client.request<types.Organization>('GET', path);
   }
 
-  async getOrganizationBySlug(params: { slug: string }): Promise<void> {
-    const path = `/slug/${params.slug}`;
-    return this.client.request<void>('GET', path);
+  async getOrganizationBySlug(params: { slug: string }): Promise<types.Organization> {
+    const path = `/organizations/slug/${params.slug}`;
+    return this.client.request<types.Organization>('GET', path);
   }
 
   async listMembers(): Promise<void> {
-    const path = '/listmembers';
+    const path = '/organizations/listmembers';
     return this.client.request<void>('GET', path);
   }
 
   async updateMember(params: { memberId: string }): Promise<void> {
-    const path = `/${params.memberId}`;
+    const path = `/organizations/${params.memberId}`;
     return this.client.request<void>('PATCH', path);
   }
 
   async acceptInvitation(params: { token: string }): Promise<void> {
-    const path = `/${params.token}/accept`;
+    const path = `/organizations/${params.token}/accept`;
     return this.client.request<void>('POST', path);
   }
 
   async declineInvitation(params: { token: string }): Promise<types.StatusResponse> {
-    const path = `/${params.token}/decline`;
+    const path = `/organizations/${params.token}/decline`;
     return this.client.request<types.StatusResponse>('POST', path);
   }
 
   async listTeams(): Promise<void> {
-    const path = '/listteams';
+    const path = '/organizations/listteams';
     return this.client.request<void>('GET', path);
   }
 

package/src/plugins/passkey.ts

@@ -13,37 +13,37 @@ export class PasskeyPlugin implements ClientPlugin {
   }
 
   async beginRegister(): Promise<void> {
-    const path = '/register/begin';
+    const path = '/passkey/register/begin';
     return this.client.request<void>('POST', path);
   }
 
   async finishRegister(): Promise<void> {
-    const path = '/register/finish';
+    const path = '/passkey/register/finish';
     return this.client.request<void>('POST', path);
   }
 
   async beginLogin(): Promise<void> {
-    const path = '/login/begin';
+    const path = '/passkey/login/begin';
     return this.client.request<void>('POST', path);
   }
 
   async finishLogin(): Promise<void> {
-    const path = '/login/finish';
+    const path = '/passkey/login/finish';
     return this.client.request<void>('POST', path);
   }
 
   async list(): Promise<void> {
-    const path = '/list';
+    const path = '/passkey/list';
     return this.client.request<void>('GET', path);
   }
 
   async update(params: { id: string }): Promise<void> {
-    const path = `/${params.id}`;
+    const path = `/passkey/${params.id}`;
     return this.client.request<void>('PUT', path);
   }
 
   async delete(params: { id: string }): Promise<types.StatusResponse> {
-    const path = `/${params.id}`;
+    const path = `/passkey/${params.id}`;
     return this.client.request<types.StatusResponse>('DELETE', path);
   }
 

package/src/plugins/permissions.ts

@@ -13,19 +13,19 @@ export class PermissionsPlugin implements ClientPlugin {
   }
 
   async migrateAll(request: types.MigrateAllRequest): Promise<types.ErrorResponse> {
-    const path = '/migrate/all';
+    const path = '/api/permissions/migrate/all';
     return this.client.request<types.ErrorResponse>('POST', path, {
       body: request,
     });
   }
 
   async migrateRoles(): Promise<types.ErrorResponse> {
-    const path = '/migrate/roles';
+    const path = '/api/permissions/migrate/roles';
     return this.client.request<types.ErrorResponse>('POST', path);
   }
 
   async previewConversion(request: types.PreviewConversionRequest): Promise<types.ErrorResponse> {
-    const path = '/migrate/preview';
+    const path = '/api/permissions/migrate/preview';
     return this.client.request<types.ErrorResponse>('POST', path, {
       body: request,
     });

package/src/plugins/secrets.ts

@@ -12,61 +12,77 @@ export class SecretsPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async list(): Promise<types.ListSecretsResponse> {
-    const path = '/list';
-    return this.client.request<types.ListSecretsResponse>('GET', path);
+  async list(request?: types.ListSecretsRequest): Promise<types.ListSecretsResponse> {
+    const path = '/secrets/list';
+    return this.client.request<types.ListSecretsResponse>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
-  async create(): Promise<types.ErrorResponse> {
-    const path = '/create';
-    return this.client.request<types.ErrorResponse>('POST', path);
+  async create(request: types.CreateSecretRequest): Promise<types.SecretDTO> {
+    const path = '/secrets/create';
+    return this.client.request<types.SecretDTO>('POST', path, {
+      body: request,
+    });
   }
 
-  async get(params: { id: string }): Promise<types.ErrorResponse> {
-    const path = `/${params.id}`;
-    return this.client.request<types.ErrorResponse>('GET', path);
+  async get(params: { id: string }, request?: types.GetSecretRequest): Promise<types.SecretDTO> {
+    const path = `/secrets/${params.id}`;
+    return this.client.request<types.SecretDTO>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
-  async getValue(params: { id: string }): Promise<types.RevealValueResponse> {
-    const path = `/${params.id}/value`;
-    return this.client.request<types.RevealValueResponse>('GET', path);
+  async getValue(params: { id: string }, request?: types.GetValueRequest): Promise<types.RevealValueResponse> {
+    const path = `/secrets/${params.id}/value`;
+    return this.client.request<types.RevealValueResponse>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
-  async update(params: { id: string }): Promise<types.ErrorResponse> {
-    const path = `/${params.id}`;
-    return this.client.request<types.ErrorResponse>('PUT', path);
+  async update(params: { id: string }, request: types.UpdateSecretRequest): Promise<types.SecretDTO> {
+    const path = `/secrets/${params.id}`;
+    return this.client.request<types.SecretDTO>('PUT', path, {
+      body: request,
+    });
   }
 
-  async delete(params: { id: string }): Promise<types.SuccessResponse> {
-    const path = `/${params.id}`;
-    return this.client.request<types.SuccessResponse>('DELETE', path);
+  async delete(params: { id: string }, request?: types.DeleteSecretRequest): Promise<types.SuccessResponse> {
+    const path = `/secrets/${params.id}`;
+    return this.client.request<types.SuccessResponse>('DELETE', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
   async getByPath(): Promise<types.ErrorResponse> {
-    const path = '/path/*path';
+    const path = '/secrets/path/*path';
     return this.client.request<types.ErrorResponse>('GET', path);
   }
 
-  async getVersions(params: { id: string }): Promise<types.ListVersionsResponse> {
-    const path = `/${params.id}/versions`;
-    return this.client.request<types.ListVersionsResponse>('GET', path);
+  async getVersions(params: { id: string }, request?: types.GetVersionsRequest): Promise<types.ListVersionsResponse> {
+    const path = `/secrets/${params.id}/versions`;
+    return this.client.request<types.ListVersionsResponse>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
-  async rollback(params: { id: string; version: number }, request: types.Rollback_req): Promise<types.ErrorResponse> {
-    const path = `/${params.id}/rollback/${params.version}`;
-    return this.client.request<types.ErrorResponse>('POST', path, {
+  async rollback(params: { id: string; version: number }, request: types.RollbackRequest): Promise<types.SecretDTO> {
+    const path = `/secrets/${params.id}/rollback/${params.version}`;
+    return this.client.request<types.SecretDTO>('POST', path, {
       body: request,
     });
   }
 
-  async getStats(): Promise<void> {
-    const path = '/stats';
-    return this.client.request<void>('GET', path);
+  async getStats(): Promise<types.StatsDTO> {
+    const path = '/secrets/stats';
+    return this.client.request<types.StatsDTO>('GET', path);
   }
 
-  async getTree(): Promise<void> {
-    const path = '/tree';
-    return this.client.request<void>('GET', path);
+  async getTree(request?: types.GetTreeRequest): Promise<types.SecretTreeNode> {
+    const path = '/secrets/tree';
+    return this.client.request<types.SecretTreeNode>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
 }

package/src/plugins/social.ts

@@ -22,7 +22,7 @@ export class SocialPlugin implements ClientPlugin {
   async callback(params: { provider: string }, query?: { state?: string; code?: string; error?: string; errorDescription?: string }): Promise<types.CallbackDataResponse> {
     const path = `/callback/${params.provider}`;
     return this.client.request<types.CallbackDataResponse>('GET', path, {
-      query,
+      query: this.client.toQueryParams(query),
     });
   }
 

package/src/plugins/sso.ts

@@ -13,38 +13,38 @@ export class SsoPlugin implements ClientPlugin {
   }
 
   async registerProvider(request: types.RegisterProviderRequest): Promise<types.ProviderRegisteredResponse> {
-    const path = '/provider/register';
+    const path = '/sso/provider/register';
     return this.client.request<types.ProviderRegisteredResponse>('POST', path, {
       body: request,
     });
   }
 
   async sAMLSPMetadata(): Promise<types.MetadataResponse> {
-    const path = '/saml2/sp/metadata';
+    const path = '/sso/saml2/sp/metadata';
     return this.client.request<types.MetadataResponse>('GET', path);
   }
 
   async sAMLLogin(params: { providerId: string }, request: types.SAMLLoginRequest): Promise<types.SAMLLoginResponse> {
-    const path = `/saml2/login/${params.providerId}`;
+    const path = `/sso/saml2/login/${params.providerId}`;
     return this.client.request<types.SAMLLoginResponse>('POST', path, {
       body: request,
     });
   }
 
   async sAMLCallback(params: { providerId: string }): Promise<types.SSOAuthResponse> {
-    const path = `/saml2/callback/${params.providerId}`;
+    const path = `/sso/saml2/callback/${params.providerId}`;
     return this.client.request<types.SSOAuthResponse>('POST', path);
   }
 
   async oIDCLogin(params: { providerId: string }, request: types.OIDCLoginRequest): Promise<types.OIDCLoginResponse> {
-    const path = `/oidc/login/${params.providerId}`;
+    const path = `/sso/oidc/login/${params.providerId}`;
     return this.client.request<types.OIDCLoginResponse>('POST', path, {
       body: request,
     });
   }
 
   async oIDCCallback(params: { providerId: string }): Promise<types.SSOAuthResponse> {
-    const path = `/oidc/callback/${params.providerId}`;
+    const path = `/sso/oidc/callback/${params.providerId}`;
     return this.client.request<types.SSOAuthResponse>('GET', path);
   }
 

package/src/plugins/stepup.ts

@@ -12,82 +12,82 @@ export class StepupPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async evaluate(request: types.EvaluateRequest): Promise<void> {
-    const path = '/evaluate';
-    return this.client.request<void>('POST', path, {
+  async evaluate(request: types.EvaluateRequest): Promise<types.StepUpEvaluationResponse> {
+    const path = '/stepup/evaluate';
+    return this.client.request<types.StepUpEvaluationResponse>('POST', path, {
       body: request,
     });
   }
 
-  async verify(request: types.VerifyRequest): Promise<void> {
-    const path = '/verify';
-    return this.client.request<void>('POST', path, {
+  async verify(request: types.VerifyRequest): Promise<types.StepUpVerificationResponse> {
+    const path = '/stepup/verify';
+    return this.client.request<types.StepUpVerificationResponse>('POST', path, {
       body: request,
     });
   }
 
-  async getRequirement(params: { id: string }): Promise<void> {
-    const path = `/requirements/${params.id}`;
-    return this.client.request<void>('GET', path);
+  async getRequirement(params: { id: string }): Promise<types.StepUpRequirementResponse> {
+    const path = `/stepup/requirements/${params.id}`;
+    return this.client.request<types.StepUpRequirementResponse>('GET', path);
   }
 
-  async listPendingRequirements(): Promise<types.RequirementsResponse> {
-    const path = '/requirements/pending';
-    return this.client.request<types.RequirementsResponse>('GET', path);
+  async listPendingRequirements(): Promise<types.StepUpRequirementsResponse> {
+    const path = '/stepup/requirements/pending';
+    return this.client.request<types.StepUpRequirementsResponse>('GET', path);
   }
 
-  async listVerifications(): Promise<void> {
-    const path = '/verifications';
-    return this.client.request<void>('GET', path);
+  async listVerifications(): Promise<types.StepUpVerificationsResponse> {
+    const path = '/stepup/verifications';
+    return this.client.request<types.StepUpVerificationsResponse>('GET', path);
   }
 
   async listRememberedDevices(): Promise<types.StepUpDevicesResponse> {
-    const path = '/devices';
+    const path = '/stepup/devices';
     return this.client.request<types.StepUpDevicesResponse>('GET', path);
   }
 
-  async forgetDevice(params: { id: string }): Promise<types.ForgetDeviceResponse> {
-    const path = `/devices/${params.id}`;
-    return this.client.request<types.ForgetDeviceResponse>('DELETE', path);
+  async forgetDevice(params: { id: string }): Promise<types.StepUpStatusResponse> {
+    const path = `/stepup/devices/${params.id}`;
+    return this.client.request<types.StepUpStatusResponse>('DELETE', path);
   }
 
-  async createPolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicy> {
-    const path = '/policies';
-    return this.client.request<types.StepUpPolicy>('POST', path, {
+  async createPolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicyResponse> {
+    const path = '/stepup/policies';
+    return this.client.request<types.StepUpPolicyResponse>('POST', path, {
       body: request,
     });
   }
 
-  async listPolicies(): Promise<void> {
-    const path = '/policies';
-    return this.client.request<void>('GET', path);
+  async listPolicies(): Promise<types.StepUpPoliciesResponse> {
+    const path = '/stepup/policies';
+    return this.client.request<types.StepUpPoliciesResponse>('GET', path);
   }
 
-  async getPolicy(params: { id: string }): Promise<void> {
-    const path = `/policies/${params.id}`;
-    return this.client.request<void>('GET', path);
+  async getPolicy(params: { id: string }): Promise<types.StepUpPolicyResponse> {
+    const path = `/stepup/policies/${params.id}`;
+    return this.client.request<types.StepUpPolicyResponse>('GET', path);
   }
 
-  async updatePolicy(params: { id: string }, request: types.StepUpPolicy): Promise<types.StepUpPolicy> {
-    const path = `/policies/${params.id}`;
-    return this.client.request<types.StepUpPolicy>('PUT', path, {
+  async updatePolicy(params: { id: string }, request: types.StepUpPolicy): Promise<types.StepUpPolicyResponse> {
+    const path = `/stepup/policies/${params.id}`;
+    return this.client.request<types.StepUpPolicyResponse>('PUT', path, {
       body: request,
     });
   }
 
-  async deletePolicy(params: { id: string }): Promise<void> {
-    const path = `/policies/${params.id}`;
-    return this.client.request<void>('DELETE', path);
+  async deletePolicy(params: { id: string }): Promise<types.StepUpStatusResponse> {
+    const path = `/stepup/policies/${params.id}`;
+    return this.client.request<types.StepUpStatusResponse>('DELETE', path);
   }
 
-  async getAuditLogs(): Promise<void> {
-    const path = '/audit';
-    return this.client.request<void>('GET', path);
+  async getAuditLogs(): Promise<types.StepUpAuditLogsResponse> {
+    const path = '/stepup/audit';
+    return this.client.request<types.StepUpAuditLogsResponse>('GET', path);
   }
 
-  async status(): Promise<void> {
-    const path = '/status';
-    return this.client.request<void>('GET', path);
+  async status(): Promise<types.StepUpStatusResponse> {
+    const path = '/stepup/status';
+    return this.client.request<types.StepUpStatusResponse>('GET', path);
   }
 
 }

package/src/plugins/twofa.ts

@@ -12,46 +12,34 @@ export class TwofaPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async enable(request: types.Enable_body): Promise<void> {
+  async enable(): Promise<void> {
     const path = '/2fa/enable';
-    return this.client.request<void>('POST', path, {
-      body: request,
-    });
+    return this.client.request<void>('POST', path);
   }
 
-  async verify(request: types.Verify_body): Promise<types.StatusResponse> {
+  async verify(): Promise<types.StatusResponse> {
     const path = '/2fa/verify';
-    return this.client.request<types.StatusResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.StatusResponse>('POST', path);
   }
 
-  async disable(request: types.Disable_body): Promise<types.StatusResponse> {
+  async disable(): Promise<types.StatusResponse> {
     const path = '/2fa/disable';
-    return this.client.request<types.StatusResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.StatusResponse>('POST', path);
   }
 
-  async generateBackupCodes(request: types.GenerateBackupCodes_body): Promise<types.CodesResponse> {
+  async generateBackupCodes(): Promise<types.CodesResponse> {
     const path = '/2fa/generate-backup-codes';
-    return this.client.request<types.CodesResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.CodesResponse>('POST', path);
   }
 
-  async sendOTP(request: types.SendOTP_body): Promise<types.OTPSentResponse> {
+  async sendOTP(): Promise<types.OTPSentResponse> {
     const path = '/2fa/send-otp';
-    return this.client.request<types.OTPSentResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.OTPSentResponse>('POST', path);
   }
 
-  async status(request: types.Status_body): Promise<types.TwoFAStatusResponse> {
+  async status(): Promise<types.TwoFAStatusResponse> {
     const path = '/2fa/status';
-    return this.client.request<types.TwoFAStatusResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.TwoFAStatusResponse>('POST', path);
   }
 
 }

package/src/plugins/username.ts

@@ -12,14 +12,18 @@ export class UsernamePlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async signUp(): Promise<types.SignUpResponse> {
+  async signUp(request: types.SignUpRequest): Promise<types.SignUpResponse> {
     const path = '/username/signup';
-    return this.client.request<types.SignUpResponse>('POST', path);
+    return this.client.request<types.SignUpResponse>('POST', path, {
+      body: request,
+    });
   }
 
-  async signIn(): Promise<types.SignInResponse> {
+  async signIn(request: types.SignInRequest): Promise<types.TwoFARequiredResponse> {
     const path = '/username/signin';
-    return this.client.request<types.SignInResponse>('POST', path);
+    return this.client.request<types.TwoFARequiredResponse>('POST', path, {
+      body: request,
+    });
   }
 
 }

package/src/plugins/webhook.ts

@@ -13,7 +13,7 @@ export class WebhookPlugin implements ClientPlugin {
   }
 
   async create(request: { url: string; events: string[]; secret?: string }): Promise<{ webhook: types.Webhook }> {
-    const path = '/webhooks';
+    const path = '/api/auth/webhooks';
     return this.client.request<{ webhook: types.Webhook }>('POST', path, {
       body: request,
       auth: true,
@@ -21,14 +21,14 @@ export class WebhookPlugin implements ClientPlugin {
   }
 
   async list(): Promise<{ webhooks: types.Webhook[] }> {
-    const path = '/webhooks';
+    const path = '/api/auth/webhooks';
     return this.client.request<{ webhooks: types.Webhook[] }>('GET', path, {
       auth: true,
     });
   }
 
   async update(request: { id: string; url?: string; events?: string[]; enabled?: boolean }): Promise<{ webhook: types.Webhook }> {
-    const path = '/webhooks/update';
+    const path = '/api/auth/webhooks/update';
     return this.client.request<{ webhook: types.Webhook }>('POST', path, {
       body: request,
       auth: true,
@@ -36,7 +36,7 @@ export class WebhookPlugin implements ClientPlugin {
   }
 
   async delete(request: { id: string }): Promise<{ success: boolean }> {
-    const path = '/webhooks/delete';
+    const path = '/api/auth/webhooks/delete';
     return this.client.request<{ success: boolean }>('POST', path, {
       body: request,
       auth: true,