@authsome/client 0.0.7 → 0.0.9

package/src/plugins/idverification.ts

@@ -13,63 +13,63 @@ export class IdverificationPlugin implements ClientPlugin {
   }
 
   async createVerificationSession(request: types.CreateVerificationSession_req): Promise<types.IDVerificationSessionResponse> {
-    const path = '/sessions';
+    const path = '/verification/sessions';
     return this.client.request<types.IDVerificationSessionResponse>('POST', path, {
       body: request,
     });
   }
 
   async getVerificationSession(params: { id: string }): Promise<types.IDVerificationSessionResponse> {
-    const path = `/sessions/${params.id}`;
+    const path = `/verification/sessions/${params.id}`;
     return this.client.request<types.IDVerificationSessionResponse>('GET', path);
   }
 
   async getVerification(params: { id: string }): Promise<types.IDVerificationResponse> {
-    const path = `/${params.id}`;
+    const path = `/verification/${params.id}`;
     return this.client.request<types.IDVerificationResponse>('GET', path);
   }
 
   async getUserVerifications(): Promise<types.IDVerificationListResponse> {
-    const path = '/me';
+    const path = '/verification/me';
     return this.client.request<types.IDVerificationListResponse>('GET', path);
   }
 
   async getUserVerificationStatus(): Promise<types.IDVerificationStatusResponse> {
-    const path = '/me/status';
+    const path = '/verification/me/status';
     return this.client.request<types.IDVerificationStatusResponse>('GET', path);
   }
 
   async requestReverification(request: types.RequestReverification_req): Promise<types.IDVerificationSessionResponse> {
-    const path = '/me/reverify';
+    const path = '/verification/me/reverify';
     return this.client.request<types.IDVerificationSessionResponse>('POST', path, {
       body: request,
     });
   }
 
   async handleWebhook(params: { provider: string }): Promise<types.IDVerificationWebhookResponse> {
-    const path = `/webhook/${params.provider}`;
+    const path = `/verification/webhook/${params.provider}`;
     return this.client.request<types.IDVerificationWebhookResponse>('POST', path);
   }
 
   async adminBlockUser(params: { userId: string }, request: types.AdminBlockUser_req): Promise<types.IDVerificationStatusResponse> {
-    const path = `/users/${params.userId}/block`;
+    const path = `/verification/admin/users/${params.userId}/block`;
     return this.client.request<types.IDVerificationStatusResponse>('POST', path, {
       body: request,
     });
   }
 
   async adminUnblockUser(params: { userId: string }): Promise<types.IDVerificationStatusResponse> {
-    const path = `/users/${params.userId}/unblock`;
+    const path = `/verification/admin/users/${params.userId}/unblock`;
     return this.client.request<types.IDVerificationStatusResponse>('POST', path);
   }
 
   async adminGetUserVerificationStatus(params: { userId: string }): Promise<types.IDVerificationStatusResponse> {
-    const path = `/users/${params.userId}/status`;
+    const path = `/verification/admin/users/${params.userId}/status`;
     return this.client.request<types.IDVerificationStatusResponse>('GET', path);
   }
 
   async adminGetUserVerifications(params: { userId: string }): Promise<types.IDVerificationListResponse> {
-    const path = `/users/${params.userId}/verifications`;
+    const path = `/verification/admin/users/${params.userId}/verifications`;
     return this.client.request<types.IDVerificationListResponse>('GET', path);
   }
 

package/src/plugins/impersonation.ts

@@ -13,32 +13,32 @@ export class ImpersonationPlugin implements ClientPlugin {
   }
 
   async startImpersonation(): Promise<types.ImpersonationStartResponse> {
-    const path = '/start';
+    const path = '/impersonation/start';
     return this.client.request<types.ImpersonationStartResponse>('POST', path);
   }
 
   async endImpersonation(): Promise<types.ImpersonationEndResponse> {
-    const path = '/end';
+    const path = '/impersonation/end';
     return this.client.request<types.ImpersonationEndResponse>('POST', path);
   }
 
   async getImpersonation(params: { id: string }): Promise<types.ImpersonationSession> {
-    const path = `/${params.id}`;
+    const path = `/impersonation/${params.id}`;
     return this.client.request<types.ImpersonationSession>('GET', path);
   }
 
   async listImpersonations(): Promise<types.ImpersonationListResponse> {
-    const path = '/';
+    const path = '/impersonation/';
     return this.client.request<types.ImpersonationListResponse>('GET', path);
   }
 
   async listAuditEvents(): Promise<types.ImpersonationAuditResponse> {
-    const path = '/audit';
+    const path = '/impersonation/audit';
     return this.client.request<types.ImpersonationAuditResponse>('GET', path);
   }
 
   async verifyImpersonation(): Promise<types.ImpersonationVerifyResponse> {
-    const path = '/verify';
+    const path = '/impersonation/verify';
     return this.client.request<types.ImpersonationVerifyResponse>('POST', path);
   }
 

package/src/plugins/jwt.ts

@@ -13,33 +13,33 @@ export class JwtPlugin implements ClientPlugin {
   }
 
   async createJWTKey(request: types.CreateJWTKeyRequest): Promise<types.JWTKey> {
-    const path = '/createjwtkey';
+    const path = '/jwt/keys';
     return this.client.request<types.JWTKey>('POST', path, {
       body: request,
     });
   }
 
   async listJWTKeys(request?: types.ListJWTKeysRequest): Promise<types.ListJWTKeysResponse> {
-    const path = '/listjwtkeys';
+    const path = '/jwt/keys';
     return this.client.request<types.ListJWTKeysResponse>('GET', path, {
       query: this.client.toQueryParams(request),
     });
   }
 
   async getJWKS(): Promise<types.JWKSResponse> {
-    const path = '/jwks';
+    const path = '/jwt/jwks';
     return this.client.request<types.JWKSResponse>('GET', path);
   }
 
   async generateToken(request: types.GenerateTokenRequest): Promise<types.GenerateTokenResponse> {
-    const path = '/generate';
+    const path = '/jwt/generate';
     return this.client.request<types.GenerateTokenResponse>('POST', path, {
       body: request,
     });
   }
 
   async verifyToken(request: types.VerifyTokenRequest): Promise<types.VerifyTokenResponse> {
-    const path = '/verify';
+    const path = '/jwt/verify';
     return this.client.request<types.VerifyTokenResponse>('POST', path, {
       body: request,
     });

package/src/plugins/multiapp.ts

@@ -13,107 +13,107 @@ export class MultiappPlugin implements ClientPlugin {
   }
 
   async createApp(): Promise<types.App> {
-    const path = '/createapp';
+    const path = '/apps';
     return this.client.request<types.App>('POST', path);
   }
 
   async getApp(params: { appId: string }): Promise<types.App> {
-    const path = `/${params.appId}`;
+    const path = `/apps/${params.appId}`;
     return this.client.request<types.App>('GET', path);
   }
 
   async updateApp(params: { appId: string }): Promise<types.App> {
-    const path = `/${params.appId}`;
+    const path = `/apps/${params.appId}`;
     return this.client.request<types.App>('PUT', path);
   }
 
   async deleteApp(params: { appId: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.appId}`;
+    const path = `/apps/${params.appId}`;
     return this.client.request<types.MultitenancyStatusResponse>('DELETE', path);
   }
 
   async listApps(): Promise<types.AppsListResponse> {
-    const path = '/listapps';
+    const path = '/apps';
     return this.client.request<types.AppsListResponse>('GET', path);
   }
 
-  async removeMember(params: { memberId: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.memberId}`;
+  async removeMember(params: { appId: string; memberId: string }): Promise<types.MultitenancyStatusResponse> {
+    const path = `/apps/${params.appId}/members/${params.memberId}`;
     return this.client.request<types.MultitenancyStatusResponse>('DELETE', path);
   }
 
-  async listMembers(): Promise<types.MembersListResponse> {
-    const path = '/listmembers';
+  async listMembers(params: { appId: string }): Promise<types.MembersListResponse> {
+    const path = `/apps/${params.appId}/members`;
     return this.client.request<types.MembersListResponse>('GET', path);
   }
 
-  async inviteMember(request: types.InviteMemberRequest): Promise<types.Invitation> {
-    const path = '/invite';
+  async inviteMember(params: { appId: string }, request: types.InviteMemberRequest): Promise<types.Invitation> {
+    const path = `/apps/${params.appId}/members/invite`;
     return this.client.request<types.Invitation>('POST', path, {
       body: request,
     });
   }
 
-  async updateMember(params: { memberId: string }, request: types.UpdateMemberRequest): Promise<types.Member> {
-    const path = `/${params.memberId}`;
+  async updateMember(params: { appId: string; memberId: string }, request: types.UpdateMemberRequest): Promise<types.Member> {
+    const path = `/apps/${params.appId}/members/${params.memberId}`;
     return this.client.request<types.Member>('PUT', path, {
       body: request,
     });
   }
 
   async getInvitation(params: { token: string }): Promise<types.Invitation> {
-    const path = `/${params.token}`;
+    const path = `/invitations/${params.token}`;
     return this.client.request<types.Invitation>('GET', path);
   }
 
   async acceptInvitation(params: { token: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.token}/accept`;
+    const path = `/invitations/${params.token}/accept`;
     return this.client.request<types.MultitenancyStatusResponse>('POST', path);
   }
 
   async declineInvitation(params: { token: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.token}/decline`;
+    const path = `/invitations/${params.token}/decline`;
     return this.client.request<types.MultitenancyStatusResponse>('POST', path);
   }
 
-  async createTeam(request: types.CreateTeamRequest): Promise<types.Team> {
-    const path = '/createteam';
+  async createTeam(params: { appId: string }, request: types.CreateTeamRequest): Promise<types.Team> {
+    const path = `/apps/${params.appId}/teams`;
     return this.client.request<types.Team>('POST', path, {
       body: request,
     });
   }
 
-  async getTeam(params: { teamId: string }): Promise<types.Team> {
-    const path = `/${params.teamId}`;
+  async getTeam(params: { appId: string; teamId: string }): Promise<types.Team> {
+    const path = `/apps/${params.appId}/teams/${params.teamId}`;
     return this.client.request<types.Team>('GET', path);
   }
 
-  async updateTeam(params: { teamId: string }, request: types.UpdateTeamRequest): Promise<types.Team> {
-    const path = `/${params.teamId}`;
+  async updateTeam(params: { appId: string; teamId: string }, request: types.UpdateTeamRequest): Promise<types.Team> {
+    const path = `/apps/${params.appId}/teams/${params.teamId}`;
     return this.client.request<types.Team>('PUT', path, {
       body: request,
     });
   }
 
-  async deleteTeam(params: { teamId: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.teamId}`;
+  async deleteTeam(params: { appId: string; teamId: string }): Promise<types.MultitenancyStatusResponse> {
+    const path = `/apps/${params.appId}/teams/${params.teamId}`;
     return this.client.request<types.MultitenancyStatusResponse>('DELETE', path);
   }
 
-  async listTeams(): Promise<types.TeamsListResponse> {
-    const path = '/listteams';
+  async listTeams(params: { appId: string }): Promise<types.TeamsListResponse> {
+    const path = `/apps/${params.appId}/teams`;
     return this.client.request<types.TeamsListResponse>('GET', path);
   }
 
-  async addTeamMember(params: { teamId: string }, request: types.AddTeamMember_req): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.teamId}/members`;
+  async addTeamMember(params: { teamId: string; appId: string }, request: types.AddTeamMember_req): Promise<types.MultitenancyStatusResponse> {
+    const path = `/apps/${params.appId}/teams/${params.teamId}/members`;
     return this.client.request<types.MultitenancyStatusResponse>('POST', path, {
       body: request,
     });
   }
 
-  async removeTeamMember(params: { teamId: string; memberId: string }): Promise<types.MultitenancyStatusResponse> {
-    const path = `/${params.teamId}/members/${params.memberId}`;
+  async removeTeamMember(params: { appId: string; teamId: string; memberId: string }): Promise<types.MultitenancyStatusResponse> {
+    const path = `/apps/${params.appId}/teams/${params.teamId}/members/${params.memberId}`;
     return this.client.request<types.MultitenancyStatusResponse>('DELETE', path);
   }
 

package/src/plugins/multisession.ts

@@ -13,53 +13,53 @@ export class MultisessionPlugin implements ClientPlugin {
   }
 
   async list(request?: types.ListSessionsRequest): Promise<types.ListSessionsResponse> {
-    const path = '/list';
+    const path = '/multi-session/list';
     return this.client.request<types.ListSessionsResponse>('GET', path, {
       query: this.client.toQueryParams(request),
     });
   }
 
   async setActive(request: types.SetActiveRequest): Promise<types.SessionTokenResponse> {
-    const path = '/set-active';
+    const path = '/multi-session/set-active';
     return this.client.request<types.SessionTokenResponse>('POST', path, {
       body: request,
     });
   }
 
   async delete(params: { id: string }): Promise<types.StatusResponse> {
-    const path = `/delete/${params.id}`;
+    const path = `/multi-session/delete/${params.id}`;
     return this.client.request<types.StatusResponse>('POST', path);
   }
 
   async getCurrent(): Promise<types.SessionTokenResponse> {
-    const path = '/current';
+    const path = '/multi-session/current';
     return this.client.request<types.SessionTokenResponse>('GET', path);
   }
 
   async getByID(params: { id: string }): Promise<types.SessionTokenResponse> {
-    const path = `/${params.id}`;
+    const path = `/multi-session/${params.id}`;
     return this.client.request<types.SessionTokenResponse>('GET', path);
   }
 
   async revokeAll(request: types.RevokeAllRequest): Promise<types.RevokeResponse> {
-    const path = '/revoke-all';
+    const path = '/multi-session/revoke-all';
     return this.client.request<types.RevokeResponse>('POST', path, {
       body: request,
     });
   }
 
   async revokeOthers(): Promise<types.RevokeResponse> {
-    const path = '/revoke-others';
+    const path = '/multi-session/revoke-others';
     return this.client.request<types.RevokeResponse>('POST', path);
   }
 
   async refresh(): Promise<types.SessionTokenResponse> {
-    const path = '/refresh';
+    const path = '/multi-session/refresh';
     return this.client.request<types.SessionTokenResponse>('POST', path);
   }
 
   async getStats(): Promise<types.SessionStatsResponse> {
-    const path = '/stats';
+    const path = '/multi-session/stats';
     return this.client.request<types.SessionStatsResponse>('GET', path);
   }
 

package/src/plugins/notification.ts

@@ -13,82 +13,82 @@ export class NotificationPlugin implements ClientPlugin {
   }
 
   async createTemplate(request: types.CreateTemplateRequest): Promise<types.NotificationTemplateResponse> {
-    const path = '/createtemplate';
+    const path = '/templates';
     return this.client.request<types.NotificationTemplateResponse>('POST', path, {
       body: request,
     });
   }
 
   async getTemplate(params: { id: string }): Promise<types.NotificationTemplateResponse> {
-    const path = `/${params.id}`;
+    const path = `/templates/${params.id}`;
     return this.client.request<types.NotificationTemplateResponse>('GET', path);
   }
 
   async listTemplates(): Promise<types.NotificationTemplateListResponse> {
-    const path = '/listtemplates';
+    const path = '/templates';
     return this.client.request<types.NotificationTemplateListResponse>('GET', path);
   }
 
   async updateTemplate(params: { id: string }, request: types.UpdateTemplateRequest): Promise<types.NotificationTemplateResponse> {
-    const path = `/${params.id}`;
+    const path = `/templates/${params.id}`;
     return this.client.request<types.NotificationTemplateResponse>('PUT', path, {
       body: request,
     });
   }
 
   async deleteTemplate(params: { id: string }): Promise<types.NotificationStatusResponse> {
-    const path = `/${params.id}`;
+    const path = `/templates/${params.id}`;
     return this.client.request<types.NotificationStatusResponse>('DELETE', path);
   }
 
   async resetTemplate(params: { id: string }): Promise<types.NotificationStatusResponse> {
-    const path = `/${params.id}/reset`;
+    const path = `/templates/${params.id}/reset`;
     return this.client.request<types.NotificationStatusResponse>('POST', path);
   }
 
   async resetAllTemplates(): Promise<types.NotificationStatusResponse> {
-    const path = '/reset-all';
+    const path = '/templates/reset-all';
     return this.client.request<types.NotificationStatusResponse>('POST', path);
   }
 
   async getTemplateDefaults(): Promise<types.NotificationTemplateListResponse> {
-    const path = '/defaults';
+    const path = '/templates/defaults';
     return this.client.request<types.NotificationTemplateListResponse>('GET', path);
   }
 
   async previewTemplate(params: { id: string }, request: types.PreviewTemplate_req): Promise<types.NotificationPreviewResponse> {
-    const path = `/${params.id}/preview`;
+    const path = `/templates/${params.id}/preview`;
     return this.client.request<types.NotificationPreviewResponse>('POST', path, {
       body: request,
     });
   }
 
   async renderTemplate(request: types.RenderTemplate_req): Promise<types.NotificationPreviewResponse> {
-    const path = '/render';
+    const path = '/templates/render';
     return this.client.request<types.NotificationPreviewResponse>('POST', path, {
       body: request,
     });
   }
 
   async sendNotification(request: types.SendRequest): Promise<types.NotificationResponse> {
-    const path = '/send';
+    const path = '/notifications/send';
     return this.client.request<types.NotificationResponse>('POST', path, {
       body: request,
     });
   }
 
   async getNotification(params: { id: string }): Promise<types.NotificationResponse> {
-    const path = `/${params.id}`;
+    const path = `/notifications/${params.id}`;
     return this.client.request<types.NotificationResponse>('GET', path);
   }
 
   async listNotifications(): Promise<types.NotificationListResponse> {
-    const path = '/listnotifications';
+    const path = '/notifications';
     return this.client.request<types.NotificationListResponse>('GET', path);
   }
 
   async resendNotification(params: { id: string }): Promise<types.NotificationResponse> {
-    const path = `/${params.id}/resend`;
+    const path = `/notifications/${params.id}/resend`;
     return this.client.request<types.NotificationResponse>('POST', path);
   }
 

package/src/plugins/oidcprovider.ts

@@ -13,104 +13,104 @@ export class OidcproviderPlugin implements ClientPlugin {
   }
 
   async registerClient(request: types.ClientRegistrationRequest): Promise<types.ClientRegistrationResponse> {
-    const path = '/register';
+    const path = '/oauth2/register';
     return this.client.request<types.ClientRegistrationResponse>('POST', path, {
       body: request,
     });
   }
 
   async listClients(): Promise<types.ClientsListResponse> {
-    const path = '/listclients';
+    const path = '/oauth2/clients';
     return this.client.request<types.ClientsListResponse>('GET', path);
   }
 
   async getClient(params: { clientId: string }): Promise<types.ClientDetailsResponse> {
-    const path = `/${params.clientId}`;
+    const path = `/oauth2/clients/${params.clientId}`;
     return this.client.request<types.ClientDetailsResponse>('GET', path);
   }
 
   async updateClient(params: { clientId: string }, request: types.ClientUpdateRequest): Promise<types.ClientDetailsResponse> {
-    const path = `/${params.clientId}`;
+    const path = `/oauth2/clients/${params.clientId}`;
     return this.client.request<types.ClientDetailsResponse>('PUT', path, {
       body: request,
     });
   }
 
   async deleteClient(params: { clientId: string }): Promise<void> {
-    const path = `/${params.clientId}`;
+    const path = `/oauth2/clients/${params.clientId}`;
     return this.client.request<void>('DELETE', path);
   }
 
   async discovery(): Promise<types.DiscoveryResponse> {
-    const path = '/.well-known/openid-configuration';
+    const path = '/oauth2/.well-known/openid-configuration';
     return this.client.request<types.DiscoveryResponse>('GET', path);
   }
 
   async jWKS(): Promise<types.JWKSResponse> {
-    const path = '/jwks';
+    const path = '/oauth2/jwks';
     return this.client.request<types.JWKSResponse>('GET', path);
   }
 
   async authorize(): Promise<void> {
-    const path = '/authorize';
+    const path = '/oauth2/authorize';
     return this.client.request<void>('GET', path);
   }
 
   async handleConsent(request: types.ConsentRequest): Promise<void> {
-    const path = '/consent';
+    const path = '/oauth2/consent';
     return this.client.request<void>('POST', path, {
       body: request,
     });
   }
 
   async token(request: types.TokenRequest): Promise<types.TokenResponse> {
-    const path = '/token';
+    const path = '/oauth2/token';
     return this.client.request<types.TokenResponse>('POST', path, {
       body: request,
     });
   }
 
   async userInfo(): Promise<types.UserInfoResponse> {
-    const path = '/userinfo';
+    const path = '/oauth2/userinfo';
     return this.client.request<types.UserInfoResponse>('GET', path);
   }
 
   async introspectToken(request: types.TokenIntrospectionRequest): Promise<types.TokenIntrospectionResponse> {
-    const path = '/introspect';
+    const path = '/oauth2/introspect';
     return this.client.request<types.TokenIntrospectionResponse>('POST', path, {
       body: request,
     });
   }
 
   async revokeToken(request: types.TokenRevocationRequest): Promise<types.StatusResponse> {
-    const path = '/revoke';
+    const path = '/oauth2/revoke';
     return this.client.request<types.StatusResponse>('POST', path, {
       body: request,
     });
   }
 
   async deviceAuthorize(request: types.DeviceAuthorizationRequest): Promise<types.DeviceAuthorizationResponse> {
-    const path = '/device_authorization';
+    const path = '/oauth2/device_authorization';
     return this.client.request<types.DeviceAuthorizationResponse>('POST', path, {
       body: request,
     });
   }
 
-  async deviceCodeEntry(): Promise<void> {
-    const path = '/devicecodeentry';
-    return this.client.request<void>('GET', path);
+  async deviceCodeEntry(): Promise<types.DeviceCodeEntryResponse> {
+    const path = '/oauth2/device';
+    return this.client.request<types.DeviceCodeEntryResponse>('GET', path);
   }
 
-  async deviceVerify(request: types.DeviceVerificationRequest): Promise<void> {
-    const path = '/verify';
-    return this.client.request<void>('POST', path, {
+  async deviceVerify(request: types.DeviceVerificationRequest): Promise<types.DeviceVerifyResponse> {
+    const path = '/oauth2/device/verify';
+    return this.client.request<types.DeviceVerifyResponse>('POST', path, {
       body: request,
     });
   }
 
-  async deviceAuthorizeDecision(request: types.DeviceAuthorizationDecisionRequest): Promise<void> {
-    const path = '/authorize';
-    return this.client.request<void>('POST', path, {
+  async deviceAuthorizeDecision(request: types.DeviceAuthorizationDecisionRequest): Promise<types.DeviceDecisionResponse> {
+    const path = '/oauth2/device/authorize';
+    return this.client.request<types.DeviceDecisionResponse>('POST', path, {
       body: request,
     });
   }