@authsome/client 0.0.4 → 0.0.5

package/src/plugins/idverification.ts

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

package/src/plugins/impersonation.ts

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

package/src/plugins/jwt.ts

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

package/src/plugins/mfa.ts

@@ -12,9 +12,9 @@ export class MfaPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async enrollFactor(request: types.FactorEnrollmentRequest): Promise<void> {
+  async enrollFactor(request: types.FactorEnrollmentRequest): Promise<types.FactorEnrollmentResponse> {
     const path = '/mfa/factors/enroll';
-    return this.client.request<void>('POST', path, {
+    return this.client.request<types.FactorEnrollmentResponse>('POST', path, {
       body: request,
     });
   }
@@ -24,9 +24,9 @@ export class MfaPlugin implements ClientPlugin {
     return this.client.request<types.FactorsResponse>('GET', path);
   }
 
-  async getFactor(params: { id: string }): Promise<void> {
+  async getFactor(params: { id: string }): Promise<types.Factor> {
     const path = `/mfa/factors/${params.id}`;
-    return this.client.request<void>('GET', path);
+    return this.client.request<types.Factor>('GET', path);
   }
 
   async updateFactor(params: { id: string }): Promise<types.MessageResponse> {
@@ -39,30 +39,28 @@ export class MfaPlugin implements ClientPlugin {
     return this.client.request<types.MessageResponse>('DELETE', path);
   }
 
-  async verifyFactor(params: { id: string }, request: types.VerifyFactor_req): Promise<types.MessageResponse> {
+  async verifyFactor(params: { id: string }): Promise<types.MessageResponse> {
     const path = `/mfa/factors/${params.id}/verify`;
-    return this.client.request<types.MessageResponse>('POST', path, {
-      body: request,
-    });
+    return this.client.request<types.MessageResponse>('POST', path);
   }
 
-  async initiateChallenge(request: types.ChallengeRequest): Promise<void> {
+  async initiateChallenge(request: types.ChallengeRequest): Promise<types.ChallengeResponse> {
     const path = '/mfa/challenge';
-    return this.client.request<void>('POST', path, {
+    return this.client.request<types.ChallengeResponse>('POST', path, {
       body: request,
     });
   }
 
-  async verifyChallenge(request: types.VerificationRequest): Promise<void> {
+  async verifyChallenge(request: types.VerificationRequest): Promise<types.VerificationResponse> {
     const path = '/mfa/verify';
-    return this.client.request<void>('POST', path, {
+    return this.client.request<types.VerificationResponse>('POST', path, {
       body: request,
     });
   }
 
-  async getChallengeStatus(params: { id: string }): Promise<void> {
+  async getChallengeStatus(params: { id: string }): Promise<types.ChallengeStatusResponse> {
     const path = `/mfa/challenge/${params.id}`;
-    return this.client.request<void>('GET', path);
+    return this.client.request<types.ChallengeStatusResponse>('GET', path);
   }
 
   async trustDevice(request: types.DeviceInfo): Promise<types.MessageResponse> {
@@ -82,9 +80,9 @@ export class MfaPlugin implements ClientPlugin {
     return this.client.request<types.MessageResponse>('DELETE', path);
   }
 
-  async getStatus(): Promise<void> {
+  async getStatus(): Promise<types.MFAStatus> {
     const path = '/mfa/status';
-    return this.client.request<void>('GET', path);
+    return this.client.request<types.MFAStatus>('GET', path);
   }
 
   async getPolicy(): Promise<types.MFAConfigResponse> {
@@ -92,16 +90,14 @@ export class MfaPlugin implements ClientPlugin {
     return this.client.request<types.MFAConfigResponse>('GET', path);
   }
 
-  async adminUpdatePolicy(request: types.AdminPolicyRequest): Promise<void> {
+  async adminUpdatePolicy(): Promise<types.StatusResponse> {
     const path = '/mfa/policy';
-    return this.client.request<void>('PUT', path, {
-      body: request,
-    });
+    return this.client.request<types.StatusResponse>('PUT', path);
   }
 
-  async adminResetUserMFA(params: { id: string }): Promise<void> {
+  async adminResetUserMFA(params: { id: string }): Promise<types.MessageResponse> {
     const path = `/mfa/users/${params.id}/reset`;
-    return this.client.request<void>('POST', path);
+    return this.client.request<types.MessageResponse>('POST', path);
   }
 
 }

package/src/plugins/multiapp.ts

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

package/src/plugins/multisession.ts

@@ -12,12 +12,14 @@ export class MultisessionPlugin implements ClientPlugin {
     this.client = client;
   }
 
-  async list(): Promise<types.SessionsResponse> {
+  async list(request?: types.ListSessionsRequest): Promise<types.ListSessionsResponse> {
     const path = '/list';
-    return this.client.request<types.SessionsResponse>('GET', path);
+    return this.client.request<types.ListSessionsResponse>('GET', path, {
+      query: this.client.toQueryParams(request),
+    });
   }
 
-  async setActive(request: types.SetActive_body): Promise<types.SessionTokenResponse> {
+  async setActive(request: types.SetActiveRequest): Promise<types.SessionTokenResponse> {
     const path = '/set-active';
     return this.client.request<types.SessionTokenResponse>('POST', path, {
       body: request,
@@ -39,16 +41,16 @@ export class MultisessionPlugin implements ClientPlugin {
     return this.client.request<types.SessionTokenResponse>('GET', path);
   }
 
-  async revokeAll(request: types.RevokeAll_body): Promise<void> {
+  async revokeAll(request: types.RevokeAllRequest): Promise<types.RevokeResponse> {
     const path = '/revoke-all';
-    return this.client.request<void>('POST', path, {
+    return this.client.request<types.RevokeResponse>('POST', path, {
       body: request,
     });
   }
 
-  async revokeOthers(): Promise<void> {
+  async revokeOthers(): Promise<types.RevokeResponse> {
     const path = '/revoke-others';
-    return this.client.request<void>('POST', path);
+    return this.client.request<types.RevokeResponse>('POST', path);
   }
 
   async refresh(): Promise<types.SessionTokenResponse> {
@@ -56,9 +58,9 @@ export class MultisessionPlugin implements ClientPlugin {
     return this.client.request<types.SessionTokenResponse>('POST', path);
   }
 
-  async getStats(): Promise<void> {
+  async getStats(): Promise<types.SessionStatsResponse> {
     const path = '/stats';
-    return this.client.request<void>('GET', path);
+    return this.client.request<types.SessionStatsResponse>('GET', path);
   }
 
 }

package/src/plugins/notification.ts

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