keplar-api 0.0.9 → 0.0.11

package/src/apis/DefaultApi.ts

@@ -19,16 +19,10 @@ import type {
   ApiDemosCreateDemoInvitePostRequest,
   ApiFilesFileIdSignedUrlPost200Response,
   ApiFilesFileIdSignedUrlPostRequest,
-  ApiInviteCodeCodeGet200Response,
-  ApiInviteCodeCodeResponsesResponseIdPut404Response,
-  ApiInviteCodeCodeResponsesResponseIdRedirectGet200Response,
-  ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest,
-  ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest,
-  ApiInviteCodeCodeStartGet302Response,
+  ApiInvitesIdParticipantInvitesGet200Response,
   ApiInvitesIdParticipantInvitesParticipantIdPutRequest,
   ApiInvitesIdParticipantInvitesPostRequest,
   ApiInvitesIdPutRequest,
-  ApiInvitesIdResponsesGet200Response,
   ApiInvitesIdResponsesPostRequest,
   ApiInvitesIdResponsesResponseIdPutRequest,
   ApiInvitesPostRequest,
@@ -49,13 +43,23 @@ import type {
   CallMetadata,
   CodeInviteResponse,
   ConversationMessage,
-  GetParticipantInvitesResponse,
-  GetProjectResponsesResponse,
+  CreateCodeInviteResponseRequest,
+  CreateEmailShareRequest,
+  CreateProjectShareRequest,
+  CreateProjectShareResponse,
+  DeleteEmailShare200Response,
+  EmailShare,
+  GetCodeInvite200Response,
+  GetCodeInviteResponseRedirect200Response,
+  GetShareEntities200Response,
+  GetSharedInviteResponses200Response,
+  GetSharedInviteResponsesStatusesParameterInner,
   InboundCallResponse,
-  Invite,
   InviteResponse,
   InviteResponseStatus,
   InviteResponseUpdateEvent,
+  InviteWithAnalytics,
+  JoinCodeInvite302Response,
   ModelFile,
   NotFoundErrorResponse,
   ParticipantInvite,
@@ -66,10 +70,19 @@ import type {
   ProjectStatus,
   ProjectWithAnalytics,
   RemainingResponsesResponse,
+  RequestShareAccess200Response,
+  RequestShareAccessRequest,
   SearchProjectTranscriptsResponse,
+  ShareEntity,
+  StartPhoneCallForCodeInviteResponseRequest,
   Thread,
   ThreadKind,
+  UpdateCallForCodeInviteResponseRequest,
+  UpdateCodeInviteResponse404Response,
+  UpdateShareEntityRequest,
   User,
+  VerifyEmailAccessForShare200Response,
+  VerifyEmailAccessForShareRequest,
 } from '../models/index';
 import {
     ApiCallMessagesSearchPost200ResponseInnerFromJSON,
@@ -80,26 +93,14 @@ import {
     ApiFilesFileIdSignedUrlPost200ResponseToJSON,
     ApiFilesFileIdSignedUrlPostRequestFromJSON,
     ApiFilesFileIdSignedUrlPostRequestToJSON,
-    ApiInviteCodeCodeGet200ResponseFromJSON,
-    ApiInviteCodeCodeGet200ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdPut404ResponseFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdPut404ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequestFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequestToJSON,
-    ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequestFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequestToJSON,
-    ApiInviteCodeCodeStartGet302ResponseFromJSON,
-    ApiInviteCodeCodeStartGet302ResponseToJSON,
+    ApiInvitesIdParticipantInvitesGet200ResponseFromJSON,
+    ApiInvitesIdParticipantInvitesGet200ResponseToJSON,
     ApiInvitesIdParticipantInvitesParticipantIdPutRequestFromJSON,
     ApiInvitesIdParticipantInvitesParticipantIdPutRequestToJSON,
     ApiInvitesIdParticipantInvitesPostRequestFromJSON,
     ApiInvitesIdParticipantInvitesPostRequestToJSON,
     ApiInvitesIdPutRequestFromJSON,
     ApiInvitesIdPutRequestToJSON,
-    ApiInvitesIdResponsesGet200ResponseFromJSON,
-    ApiInvitesIdResponsesGet200ResponseToJSON,
     ApiInvitesIdResponsesPostRequestFromJSON,
     ApiInvitesIdResponsesPostRequestToJSON,
     ApiInvitesIdResponsesResponseIdPutRequestFromJSON,
@@ -140,20 +141,40 @@ import {
     CodeInviteResponseToJSON,
     ConversationMessageFromJSON,
     ConversationMessageToJSON,
-    GetParticipantInvitesResponseFromJSON,
-    GetParticipantInvitesResponseToJSON,
-    GetProjectResponsesResponseFromJSON,
-    GetProjectResponsesResponseToJSON,
+    CreateCodeInviteResponseRequestFromJSON,
+    CreateCodeInviteResponseRequestToJSON,
+    CreateEmailShareRequestFromJSON,
+    CreateEmailShareRequestToJSON,
+    CreateProjectShareRequestFromJSON,
+    CreateProjectShareRequestToJSON,
+    CreateProjectShareResponseFromJSON,
+    CreateProjectShareResponseToJSON,
+    DeleteEmailShare200ResponseFromJSON,
+    DeleteEmailShare200ResponseToJSON,
+    EmailShareFromJSON,
+    EmailShareToJSON,
+    GetCodeInvite200ResponseFromJSON,
+    GetCodeInvite200ResponseToJSON,
+    GetCodeInviteResponseRedirect200ResponseFromJSON,
+    GetCodeInviteResponseRedirect200ResponseToJSON,
+    GetShareEntities200ResponseFromJSON,
+    GetShareEntities200ResponseToJSON,
+    GetSharedInviteResponses200ResponseFromJSON,
+    GetSharedInviteResponses200ResponseToJSON,
+    GetSharedInviteResponsesStatusesParameterInnerFromJSON,
+    GetSharedInviteResponsesStatusesParameterInnerToJSON,
     InboundCallResponseFromJSON,
     InboundCallResponseToJSON,
-    InviteFromJSON,
-    InviteToJSON,
     InviteResponseFromJSON,
     InviteResponseToJSON,
     InviteResponseStatusFromJSON,
     InviteResponseStatusToJSON,
     InviteResponseUpdateEventFromJSON,
     InviteResponseUpdateEventToJSON,
+    InviteWithAnalyticsFromJSON,
+    InviteWithAnalyticsToJSON,
+    JoinCodeInvite302ResponseFromJSON,
+    JoinCodeInvite302ResponseToJSON,
     ModelFileFromJSON,
     ModelFileToJSON,
     NotFoundErrorResponseFromJSON,
@@ -174,14 +195,32 @@ import {
     ProjectWithAnalyticsToJSON,
     RemainingResponsesResponseFromJSON,
     RemainingResponsesResponseToJSON,
+    RequestShareAccess200ResponseFromJSON,
+    RequestShareAccess200ResponseToJSON,
+    RequestShareAccessRequestFromJSON,
+    RequestShareAccessRequestToJSON,
     SearchProjectTranscriptsResponseFromJSON,
     SearchProjectTranscriptsResponseToJSON,
+    ShareEntityFromJSON,
+    ShareEntityToJSON,
+    StartPhoneCallForCodeInviteResponseRequestFromJSON,
+    StartPhoneCallForCodeInviteResponseRequestToJSON,
     ThreadFromJSON,
     ThreadToJSON,
     ThreadKindFromJSON,
     ThreadKindToJSON,
+    UpdateCallForCodeInviteResponseRequestFromJSON,
+    UpdateCallForCodeInviteResponseRequestToJSON,
+    UpdateCodeInviteResponse404ResponseFromJSON,
+    UpdateCodeInviteResponse404ResponseToJSON,
+    UpdateShareEntityRequestFromJSON,
+    UpdateShareEntityRequestToJSON,
     UserFromJSON,
     UserToJSON,
+    VerifyEmailAccessForShare200ResponseFromJSON,
+    VerifyEmailAccessForShare200ResponseToJSON,
+    VerifyEmailAccessForShareRequestFromJSON,
+    VerifyEmailAccessForShareRequestToJSON,
 } from '../models/index';
 
 export interface ApiCallMessagesSearchPostRequest {
@@ -214,88 +253,13 @@ export interface ApiFilesFileIdSignedUrlPostOperationRequest {
     apiFilesFileIdSignedUrlPostRequest?: ApiFilesFileIdSignedUrlPostRequest;
 }
 
-export interface ApiInviteCodeCodeGetRequest {
+export interface ApiInviteCodeCodeParticipantCodeParticipantCodeJoinGetRequest {
     code: string;
-    participantCode?: string;
-}
-
-export interface ApiInviteCodeCodeParticipantCodeParticipantCodeGetRequest {
-    code: string;
-    participantCode: string;
-}
-
-export interface ApiInviteCodeCodeParticipantCodeParticipantCodeStartGetRequest {
-    code: string;
-    participantCode: string;
-}
-
-export interface ApiInviteCodeCodeParticipantCodeParticipantCodeTestPostRequest {
-    code: string;
-    participantCode: string;
-    status?: InviteResponseStatus;
-}
-
-export interface ApiInviteCodeCodeParticipantResponseGetRequest {
     participantCode: string;
-    code: string;
-}
-
-export interface ApiInviteCodeCodeRemainingResponsesGetRequest {
-    responseId: string;
-    code: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdCallMetadataGetRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdCreateNewResponsePostRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdGetRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdPutRequest {
-    code: string;
-    responseId: string;
-    inviteResponseUpdateEvent?: InviteResponseUpdateEvent;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdRedirectGetRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdStartCallGetRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostOperationRequest {
-    code: string;
-    responseId: string;
-    apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest: ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdTranscriptInsightPostRequest {
-    code: string;
-    responseId: string;
-}
-
-export interface ApiInviteCodeCodeResponsesResponseIdUpdateCallPutOperationRequest {
-    code: string;
-    responseId: string;
-    apiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest: ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest;
 }
 
 export interface ApiInviteCodeCodeStartGetRequest {
-    code: string | null;
-    rdud?: string;
+    code: string;
 }
 
 export interface ApiInvitesIdGetRequest {
@@ -304,6 +268,8 @@ export interface ApiInvitesIdGetRequest {
 
 export interface ApiInvitesIdParticipantInvitesGetRequest {
     id: string;
+    page?: number;
+    limit?: number;
 }
 
 export interface ApiInvitesIdParticipantInvitesParticipantIdGetRequest {
@@ -332,11 +298,18 @@ export interface ApiInvitesIdPutOperationRequest {
     apiInvitesIdPutRequest: ApiInvitesIdPutRequest;
 }
 
+export interface ApiInvitesIdResponseAttributeStatsGetRequest {
+    id: string;
+    statuses?: Array<InviteResponseStatus>;
+    filters?: string;
+}
+
 export interface ApiInvitesIdResponsesGetRequest {
     id: string;
     page?: number;
     limit?: number;
     statuses?: Array<InviteResponseStatus>;
+    filters?: string;
 }
 
 export interface ApiInvitesIdResponsesPostOperationRequest {
@@ -424,19 +397,6 @@ export interface ApiProjectsProjectIdPutOperationRequest {
     apiProjectsProjectIdPutRequest?: ApiProjectsProjectIdPutRequest;
 }
 
-export interface ApiProjectsProjectIdResponseAttributeStatsGetRequest {
-    projectId: string;
-    inviteId?: string;
-}
-
-export interface ApiProjectsProjectIdResponsesGetRequest {
-    projectId: string;
-    page?: number;
-    limit?: number;
-    inviteId?: string;
-    filters?: string;
-}
-
 export interface ApiProjectsProjectIdSearchTranscriptsPostOperationRequest {
     projectId: string;
     apiProjectsProjectIdSearchTranscriptsPostRequest?: ApiProjectsProjectIdSearchTranscriptsPostRequest;
@@ -474,6 +434,170 @@ export interface ApiUsersIdGetRequest {
     id: string;
 }
 
+export interface CreateCodeInviteResponseOperationRequest {
+    code: string;
+    participantCode?: string;
+    createCodeInviteResponseRequest?: CreateCodeInviteResponseRequest;
+}
+
+export interface CreateCodeInviteResponseFromExistingRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface CreateEmailShareOperationRequest {
+    shareEntityId: string;
+    createEmailShareRequest: CreateEmailShareRequest;
+}
+
+export interface CreateProjectShareOperationRequest {
+    projectId: string;
+    createProjectShareRequest?: CreateProjectShareRequest;
+}
+
+export interface CreateTestParticipantCodeInviteRequest {
+    code: string;
+    participantCode: string;
+    status?: InviteResponseStatus;
+}
+
+export interface CreateTranscriptInsightForCodeInviteResponseRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface DeleteEmailShareRequest {
+    shareEntityId: string;
+    email: string;
+}
+
+export interface DownloadInviteResponsesRequest {
+    id: string;
+    statuses?: Array<InviteResponseStatus>;
+    filters?: string;
+}
+
+export interface DownloadShareInviteResponsesRequest {
+    shareToken: string;
+    inviteId: string;
+    statuses?: Array<InviteResponseStatus>;
+    filters?: string;
+}
+
+export interface GetCallMetadataForCodeInviteResponseRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface GetCodeInviteRequest {
+    code: string;
+    participantCode?: string;
+}
+
+export interface GetCodeInviteParticipantRemainingResponsesRequest {
+    responseId: string;
+    code: string;
+}
+
+export interface GetCodeInviteParticipantResponseRequest {
+    participantCode: string;
+    code: string;
+}
+
+export interface GetCodeInviteResponseRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface GetCodeInviteResponseRedirectRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface GetCodeParticipantInviteRequest {
+    code: string;
+    participantCode: string;
+}
+
+export interface GetSharedCallRequest {
+    shareToken: string;
+    callId: string;
+}
+
+export interface GetSharedCallMetadataRequest {
+    shareToken: string;
+    inviteId: string;
+    responseId: string;
+}
+
+export interface GetSharedInviteResponseAttributeStatsRequest {
+    shareToken: string;
+    inviteId: string;
+    statuses?: Array<GetSharedInviteResponsesStatusesParameterInner>;
+    filters?: string;
+}
+
+export interface GetSharedInviteResponsesRequest {
+    shareToken: string;
+    inviteId: string;
+    page?: number;
+    limit?: number;
+    statuses?: Array<GetSharedInviteResponsesStatusesParameterInner>;
+    filters?: string;
+}
+
+export interface GetSharedProjectRequest {
+    shareToken: string;
+}
+
+export interface JoinCodeInviteRequest {
+    code: string;
+    rdud?: string | null;
+}
+
+export interface JoinParticipantCodeInviteRequest {
+    code: string;
+    participantCode: string;
+}
+
+export interface RequestShareAccessOperationRequest {
+    shareToken: string;
+    requestShareAccessRequest: RequestShareAccessRequest;
+}
+
+export interface StartCallForCodeInviteResponseRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface StartPhoneCallForCodeInviteResponseOperationRequest {
+    code: string;
+    responseId: string;
+    startPhoneCallForCodeInviteResponseRequest: StartPhoneCallForCodeInviteResponseRequest;
+}
+
+export interface UpdateCallForCodeInviteResponseOperationRequest {
+    code: string;
+    responseId: string;
+    updateCallForCodeInviteResponseRequest: UpdateCallForCodeInviteResponseRequest;
+}
+
+export interface UpdateCodeInviteResponseRequest {
+    code: string;
+    responseId: string;
+    inviteResponseUpdateEvent?: InviteResponseUpdateEvent;
+}
+
+export interface UpdateShareEntityOperationRequest {
+    shareEntityId: string;
+    updateShareEntityRequest?: UpdateShareEntityRequest;
+}
+
+export interface VerifyEmailAccessForShareOperationRequest {
+    shareToken: string;
+    verifyEmailAccessForShareRequest: VerifyEmailAccessForShareRequest;
+}
+
 /**
  * 
  */
@@ -942,23 +1066,24 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Get an invite using invite code
-     * Get invite by code
      */
-    async apiInviteCodeCodeGetRaw(requestParameters: ApiInviteCodeCodeGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiInviteCodeCodeGet200Response>> {
+    async apiInviteCodeCodeParticipantCodeParticipantCodeJoinGetRaw(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeJoinGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
                 'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeGet().'
+                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeJoinGet().'
             );
         }
 
-        const queryParameters: any = {};
-
-        if (requestParameters['participantCode'] != null) {
-            queryParameters['participantCode'] = requestParameters['participantCode'];
+        if (requestParameters['participantCode'] == null) {
+            throw new runtime.RequiredError(
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeJoinGet().'
+            );
         }
 
+        const queryParameters: any = {};
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -970,8 +1095,9 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/`;
+        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}/join`;
         urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
 
         const response = await this.request({
             path: urlPath,
@@ -980,34 +1106,22 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInviteCodeCodeGet200ResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get an invite using invite code
-     * Get invite by code
      */
-    async apiInviteCodeCodeGet(requestParameters: ApiInviteCodeCodeGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiInviteCodeCodeGet200Response> {
-        const response = await this.apiInviteCodeCodeGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async apiInviteCodeCodeParticipantCodeParticipantCodeJoinGet(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeJoinGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiInviteCodeCodeParticipantCodeParticipantCodeJoinGetRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get a participant invite using invite code and participant code
-     * Get participant invite by code and participant code
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeGetRaw(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+    async apiInviteCodeCodeStartGetRaw(requestParameters: ApiInviteCodeCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
                 'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeGet().'
-            );
-        }
-
-        if (requestParameters['participantCode'] == null) {
-            throw new runtime.RequiredError(
-                'participantCode',
-                'Required parameter "participantCode" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeGet().'
+                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeStartGet().'
             );
         }
 
@@ -1024,9 +1138,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}`;
+        let urlPath = `/api/inviteCode/{code}/start`;
         urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
 
         const response = await this.request({
             path: urlPath,
@@ -1035,34 +1148,23 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get a participant invite using invite code and participant code
-     * Get participant invite by code and participant code
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeGet(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
-        const response = await this.apiInviteCodeCodeParticipantCodeParticipantCodeGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async apiInviteCodeCodeStartGet(requestParameters: ApiInviteCodeCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiInviteCodeCodeStartGetRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Start an invite using invite code and participant code
-     * Start invite by code and participant code
+     * Get invite
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeStartGetRaw(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['code'] == null) {
-            throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeStartGet().'
-            );
-        }
-
-        if (requestParameters['participantCode'] == null) {
+    async apiInvitesIdGetRaw(requestParameters: ApiInvitesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteWithAnalytics>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'participantCode',
-                'Required parameter "participantCode" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeStartGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdGet().'
             );
         }
 
@@ -1079,9 +1181,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}/start`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
+        let urlPath = `/api/invites/{id}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
@@ -1090,45 +1191,42 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Start an invite using invite code and participant code
-     * Start invite by code and participant code
+     * Get invite
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeStartGet(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiInviteCodeCodeParticipantCodeParticipantCodeStartGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdGet(requestParameters: ApiInvitesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteWithAnalytics> {
+        const response = await this.apiInvitesIdGetRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Create a test invite using invite code and participant code
-     * Create test invite by code and participant code
+     * Get all participant invites for an invite using invite ID
+     * Get participant invites
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeTestPostRaw(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeTestPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
-        if (requestParameters['code'] == null) {
-            throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeTestPost().'
-            );
-        }
-
-        if (requestParameters['participantCode'] == null) {
+    async apiInvitesIdParticipantInvitesGetRaw(requestParameters: ApiInvitesIdParticipantInvitesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiInvitesIdParticipantInvitesGet200Response>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'participantCode',
-                'Required parameter "participantCode" was null or undefined when calling apiInviteCodeCodeParticipantCodeParticipantCodeTestPost().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesGet().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['status'] != null) {
-            queryParameters['status'] = requestParameters['status'];
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
         }
 
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        if (this.configuration && this.configuration.accessToken) {
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
 
@@ -1137,54 +1235,49 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}/test`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
+        let urlPath = `/api/invites/{id}/participantInvites`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInvitesIdParticipantInvitesGet200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create a test invite using invite code and participant code
-     * Create test invite by code and participant code
+     * Get all participant invites for an invite using invite ID
+     * Get participant invites
      */
-    async apiInviteCodeCodeParticipantCodeParticipantCodeTestPost(requestParameters: ApiInviteCodeCodeParticipantCodeParticipantCodeTestPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
-        const response = await this.apiInviteCodeCodeParticipantCodeParticipantCodeTestPostRaw(requestParameters, initOverrides);
+    async apiInvitesIdParticipantInvitesGet(requestParameters: ApiInvitesIdParticipantInvitesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiInvitesIdParticipantInvitesGet200Response> {
+        const response = await this.apiInvitesIdParticipantInvitesGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get the invite response for an invite using invite code and participant code
-     * Get invite response by invite code and participant code
+     * Get a participant invite using invite ID and participant ID
+     * Get participant invite
      */
-    async apiInviteCodeCodeParticipantResponseGetRaw(requestParameters: ApiInviteCodeCodeParticipantResponseGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
-        if (requestParameters['participantCode'] == null) {
+    async apiInvitesIdParticipantInvitesParticipantIdGetRaw(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'participantCode',
-                'Required parameter "participantCode" was null or undefined when calling apiInviteCodeCodeParticipantResponseGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdGet().'
             );
         }
 
-        if (requestParameters['code'] == null) {
+        if (requestParameters['participantId'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeParticipantResponseGet().'
+                'participantId',
+                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdGet().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['participantCode'] != null) {
-            queryParameters['participantCode'] = requestParameters['participantCode'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -1196,8 +1289,9 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/participantResponse`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/{id}/participantInvites/{participantId}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -1206,45 +1300,43 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
     }
 
     /**
-     * Get the invite response for an invite using invite code and participant code
-     * Get invite response by invite code and participant code
+     * Get a participant invite using invite ID and participant ID
+     * Get participant invite
      */
-    async apiInviteCodeCodeParticipantResponseGet(requestParameters: ApiInviteCodeCodeParticipantResponseGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
-        const response = await this.apiInviteCodeCodeParticipantResponseGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdParticipantInvitesParticipantIdGet(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
+        const response = await this.apiInvitesIdParticipantInvitesParticipantIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get the number of remaining responses for an invite using invite code
-     * Get remaining responses count by invite code
+     * Update a participant invite using invite ID and participant ID
+     * Update participant invite
      */
-    async apiInviteCodeCodeRemainingResponsesGetRaw(requestParameters: ApiInviteCodeCodeRemainingResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RemainingResponsesResponse>> {
-        if (requestParameters['responseId'] == null) {
+    async apiInvitesIdParticipantInvitesParticipantIdPutRaw(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeRemainingResponsesGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdPut().'
             );
         }
 
-        if (requestParameters['code'] == null) {
+        if (requestParameters['participantId'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeRemainingResponsesGet().'
+                'participantId',
+                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdPut().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['responseId'] != null) {
-            queryParameters['responseId'] = requestParameters['responseId'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1254,44 +1346,46 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/remainingResponses`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/{id}/participantInvites/{participantId}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiInvitesIdParticipantInvitesParticipantIdPutRequestToJSON(requestParameters['apiInvitesIdParticipantInvitesParticipantIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => RemainingResponsesResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
     }
 
     /**
-     * Get the number of remaining responses for an invite using invite code
-     * Get remaining responses count by invite code
+     * Update a participant invite using invite ID and participant ID
+     * Update participant invite
      */
-    async apiInviteCodeCodeRemainingResponsesGet(requestParameters: ApiInviteCodeCodeRemainingResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RemainingResponsesResponse> {
-        const response = await this.apiInviteCodeCodeRemainingResponsesGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdParticipantInvitesParticipantIdPut(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
+        const response = await this.apiInvitesIdParticipantInvitesParticipantIdPutRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get a call metadata of an invite using invite code and response ID
-     * Get call metadata by invite code
+     * Create a participant invite using invite ID
+     * Create participant invite
      */
-    async apiInviteCodeCodeResponsesResponseIdCallMetadataGetRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdParticipantInvitesPostRaw(requestParameters: ApiInvitesIdParticipantInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdCallMetadataGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesPost().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
+        if (requestParameters['apiInvitesIdParticipantInvitesPostRequest'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdCallMetadataGet().'
+                'apiInvitesIdParticipantInvitesPostRequest',
+                'Required parameter "apiInvitesIdParticipantInvitesPostRequest" was null or undefined when calling apiInvitesIdParticipantInvitesPost().'
             );
         }
 
@@ -1299,6 +1393,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1308,45 +1404,44 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/callMetadata`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/participantInvites`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiInvitesIdParticipantInvitesPostRequestToJSON(requestParameters['apiInvitesIdParticipantInvitesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
     }
 
     /**
-     * Get a call metadata of an invite using invite code and response ID
-     * Get call metadata by invite code
+     * Create a participant invite using invite ID
+     * Create participant invite
      */
-    async apiInviteCodeCodeResponsesResponseIdCallMetadataGet(requestParameters: ApiInviteCodeCodeResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdCallMetadataGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdParticipantInvitesPost(requestParameters: ApiInvitesIdParticipantInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
+        const response = await this.apiInvitesIdParticipantInvitesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a response from an existing response
-     * Create invite response from existing response
+     * Get call metadata by invite ID and participant ID
      */
-    async apiInviteCodeCodeResponsesResponseIdCreateNewResponsePostRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdCreateNewResponsePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdCreateNewResponsePost().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
+        if (requestParameters['participantId'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdCreateNewResponsePost().'
+                'participantId',
+                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
             );
         }
 
@@ -1363,45 +1458,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/createNewResponse`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/participants/{participantId}/callMetadata`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Create a response from an existing response
-     * Create invite response from existing response
+     * Get call metadata by invite ID and participant ID
      */
-    async apiInviteCodeCodeResponsesResponseIdCreateNewResponsePost(requestParameters: ApiInviteCodeCodeResponsesResponseIdCreateNewResponsePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdCreateNewResponsePostRaw(requestParameters, initOverrides);
+    async apiInvitesIdParticipantsParticipantIdCallMetadataGet(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get a response of an invite using invite code and response ID
-     * Get invite response by invite code
+     * Update invite
      */
-    async apiInviteCodeCodeResponsesResponseIdGetRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdPutRaw(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteWithAnalytics>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdPut().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
+        if (requestParameters['apiInvitesIdPutRequest'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdGet().'
+                'apiInvitesIdPutRequest',
+                'Required parameter "apiInvitesIdPutRequest" was null or undefined when calling apiInvitesIdPut().'
             );
         }
 
@@ -1409,6 +1502,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1418,54 +1513,51 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiInvitesIdPutRequestToJSON(requestParameters['apiInvitesIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Get a response of an invite using invite code and response ID
-     * Get invite response by invite code
+     * Update invite
      */
-    async apiInviteCodeCodeResponsesResponseIdGet(requestParameters: ApiInviteCodeCodeResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdPut(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteWithAnalytics> {
+        const response = await this.apiInvitesIdPutRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update a response of an invite using invite code and response ID
-     * Update invite response by invite code
+     * Get invite response attribute stats
      */
-    async apiInviteCodeCodeResponsesResponseIdPutRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdPutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdResponseAttributeStatsGetRaw(requestParameters: ApiInvitesIdResponseAttributeStatsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AttributeStatsSchemaInner>>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdPut().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponseAttributeStatsGet().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
-            throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdPut().'
-            );
+        const queryParameters: any = {};
+
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
         }
 
-        const queryParameters: any = {};
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1475,50 +1567,56 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/responseAttributeStats`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: InviteResponseUpdateEventToJSON(requestParameters['inviteResponseUpdateEvent']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AttributeStatsSchemaInnerFromJSON));
     }
 
     /**
-     * Update a response of an invite using invite code and response ID
-     * Update invite response by invite code
+     * Get invite response attribute stats
      */
-    async apiInviteCodeCodeResponsesResponseIdPut(requestParameters: ApiInviteCodeCodeResponsesResponseIdPutRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdPutRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponseAttributeStatsGet(requestParameters: ApiInvitesIdResponseAttributeStatsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AttributeStatsSchemaInner>> {
+        const response = await this.apiInvitesIdResponseAttributeStatsGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get a redirect URL for an invite using invite code and response ID
-     * Get redirect URL by invite code
+     * Get all invite responses for an invite using invite ID
+     * Get invite responses
      */
-    async apiInviteCodeCodeResponsesResponseIdRedirectGetRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdRedirectGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiInviteCodeCodeResponsesResponseIdRedirectGet200Response>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdResponsesGetRaw(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSharedInviteResponses200Response>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdRedirectGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesGet().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
-            throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdRedirectGet().'
-            );
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
         }
 
-        const queryParameters: any = {};
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
+        }
+
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -1531,9 +1629,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/redirect`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/responses`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
@@ -1542,34 +1639,27 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetSharedInviteResponses200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get a redirect URL for an invite using invite code and response ID
-     * Get redirect URL by invite code
+     * Get all invite responses for an invite using invite ID
+     * Get invite responses
      */
-    async apiInviteCodeCodeResponsesResponseIdRedirectGet(requestParameters: ApiInviteCodeCodeResponsesResponseIdRedirectGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiInviteCodeCodeResponsesResponseIdRedirectGet200Response> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdRedirectGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponsesGet(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSharedInviteResponses200Response> {
+        const response = await this.apiInvitesIdResponsesGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Start a call for an invite using invite code and response ID
-     * Start call by invite code
+     * Create an invite response using invite ID
+     * Create invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdStartCallGetRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdStartCallGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InboundCallResponse>> {
-        if (requestParameters['code'] == null) {
-            throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdStartCallGet().'
-            );
-        }
-
-        if (requestParameters['responseId'] == null) {
+    async apiInvitesIdResponsesPostRaw(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdStartCallGet().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesPost().'
             );
         }
 
@@ -1577,6 +1667,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1586,52 +1678,44 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/startCall`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/invites/{id}/responses`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiInvitesIdResponsesPostRequestToJSON(requestParameters['apiInvitesIdResponsesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InboundCallResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Start a call for an invite using invite code and response ID
-     * Start call by invite code
+     * Create an invite response using invite ID
+     * Create invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdStartCallGet(requestParameters: ApiInviteCodeCodeResponsesResponseIdStartCallGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InboundCallResponse> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdStartCallGetRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponsesPost(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
+        const response = await this.apiInvitesIdResponsesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Start a phone call for an invite using invite code and response ID
-     * Start phone call by invite code
+     * Get call metadata by invite ID and response ID
      */
-    async apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PhoneCallStartResponse>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdStartPhoneCallPost().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
             );
         }
 
         if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
                 'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdStartPhoneCallPost().'
-            );
-        }
-
-        if (requestParameters['apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest'] == null) {
-            throw new runtime.RequiredError(
-                'apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest',
-                'Required parameter "apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdStartPhoneCallPost().'
+                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
             );
         }
 
@@ -1639,8 +1723,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1650,46 +1732,44 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/startPhoneCall`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/{id}/responses/{responseId}/callMetadata`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
         urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequestToJSON(requestParameters['apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => PhoneCallStartResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Start a phone call for an invite using invite code and response ID
-     * Start phone call by invite code
+     * Get call metadata by invite ID and response ID
      */
-    async apiInviteCodeCodeResponsesResponseIdStartPhoneCallPost(requestParameters: ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PhoneCallStartResponse> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponsesResponseIdCallMetadataGet(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a call metadata transcript insight for an invite using invite code and response ID
-     * Create call metadata transcript insight by invite code
+     * Get an invite response using invite ID and response ID
+     * Get invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdTranscriptInsightPostRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdTranscriptInsightPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdResponsesResponseIdGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdTranscriptInsightPost().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
             );
         }
 
         if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
                 'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdTranscriptInsightPost().'
+                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
             );
         }
 
@@ -1706,52 +1786,52 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/transcriptInsight`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/{id}/responses/{responseId}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
         urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create a call metadata transcript insight for an invite using invite code and response ID
-     * Create call metadata transcript insight by invite code
+     * Get an invite response using invite ID and response ID
+     * Get invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdTranscriptInsightPost(requestParameters: ApiInviteCodeCodeResponsesResponseIdTranscriptInsightPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdTranscriptInsightPostRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponsesResponseIdGet(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
+        const response = await this.apiInvitesIdResponsesResponseIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update a call for an invite using invite code and response ID
-     * Update call by invite code
+     * Update an invite response using invite ID and response ID
+     * Update invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdUpdateCallPutRaw(requestParameters: ApiInviteCodeCodeResponsesResponseIdUpdateCallPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesIdResponsesResponseIdPutRaw(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdUpdateCallPut().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
             );
         }
 
         if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
                 'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdUpdateCallPut().'
+                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
             );
         }
 
-        if (requestParameters['apiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest'] == null) {
+        if (requestParameters['apiInvitesIdResponsesResponseIdPutRequest'] == null) {
             throw new runtime.RequiredError(
-                'apiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest',
-                'Required parameter "apiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdUpdateCallPut().'
+                'apiInvitesIdResponsesResponseIdPutRequest',
+                'Required parameter "apiInvitesIdResponsesResponseIdPutRequest" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
             );
         }
 
@@ -1770,8 +1850,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/updateCall`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/{id}/responses/{responseId}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
         urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
@@ -1779,45 +1859,38 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequestToJSON(requestParameters['apiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest']),
+            body: ApiInvitesIdResponsesResponseIdPutRequestToJSON(requestParameters['apiInvitesIdResponsesResponseIdPutRequest']),
         }, initOverrides);
 
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse<any>(response);
-        } else {
-            return new runtime.TextApiResponse(response) as any;
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Update a call for an invite using invite code and response ID
-     * Update call by invite code
+     * Update an invite response using invite ID and response ID
+     * Update invite response
      */
-    async apiInviteCodeCodeResponsesResponseIdUpdateCallPut(requestParameters: ApiInviteCodeCodeResponsesResponseIdUpdateCallPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
-        const response = await this.apiInviteCodeCodeResponsesResponseIdUpdateCallPutRaw(requestParameters, initOverrides);
+    async apiInvitesIdResponsesResponseIdPut(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
+        const response = await this.apiInvitesIdResponsesResponseIdPutRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Start an invite using invite code
-     * Start invite by code
+     * Create invite
      */
-    async apiInviteCodeCodeStartGetRaw(requestParameters: ApiInviteCodeCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['code'] == null) {
+    async apiInvitesPostRaw(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteWithAnalytics>> {
+        if (requestParameters['apiInvitesPostRequest'] == null) {
             throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeStartGet().'
+                'apiInvitesPostRequest',
+                'Required parameter "apiInvitesPostRequest" was null or undefined when calling apiInvitesPost().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['rdud'] != null) {
-            queryParameters['rdud'] = requestParameters['rdud'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1827,40 +1900,37 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/inviteCode/{code}/start`;
-        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        let urlPath = `/api/invites/`;
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiInvitesPostRequestToJSON(requestParameters['apiInvitesPostRequest']),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => InviteWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Start an invite using invite code
-     * Start invite by code
+     * Create invite
      */
-    async apiInviteCodeCodeStartGet(requestParameters: ApiInviteCodeCodeStartGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiInviteCodeCodeStartGetRaw(requestParameters, initOverrides);
+    async apiInvitesPost(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteWithAnalytics> {
+        const response = await this.apiInvitesPostRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get invite
+     * Get draft project
      */
-    async apiInvitesIdGetRaw(requestParameters: ApiInvitesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Invite>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdGet().'
-            );
-        }
-
+    async apiProjectsDraftGetRaw(requestParameters: ApiProjectsDraftGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Project>> {
         const queryParameters: any = {};
 
+        if (requestParameters['create'] != null) {
+            queryParameters['create'] = requestParameters['create'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -1872,8 +1942,7 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/projects/draft`;
 
         const response = await this.request({
             path: urlPath,
@@ -1882,30 +1951,38 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
     }
 
     /**
-     * Get invite
+     * Get draft project
      */
-    async apiInvitesIdGet(requestParameters: ApiInvitesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Invite> {
-        const response = await this.apiInvitesIdGetRaw(requestParameters, initOverrides);
+    async apiProjectsDraftGet(requestParameters: ApiProjectsDraftGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Project> {
+        const response = await this.apiProjectsDraftGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all participant invites for an invite using invite ID
-     * Get participant invites
+     * Get projects
      */
-    async apiInvitesIdParticipantInvitesGetRaw(requestParameters: ApiInvitesIdParticipantInvitesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetParticipantInvitesResponse>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesGet().'
-            );
+    async apiProjectsGetRaw(requestParameters: ApiProjectsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsGet200Response>> {
+        const queryParameters: any = {};
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
         }
 
-        const queryParameters: any = {};
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
+        }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -1918,8 +1995,7 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participantInvites`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/projects/`;
 
         const response = await this.request({
             path: urlPath,
@@ -1928,34 +2004,25 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GetParticipantInvitesResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsGet200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get all participant invites for an invite using invite ID
-     * Get participant invites
+     * Get projects
      */
-    async apiInvitesIdParticipantInvitesGet(requestParameters: ApiInvitesIdParticipantInvitesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetParticipantInvitesResponse> {
-        const response = await this.apiInvitesIdParticipantInvitesGetRaw(requestParameters, initOverrides);
+    async apiProjectsGet(requestParameters: ApiProjectsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsGet200Response> {
+        const response = await this.apiProjectsGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get a participant invite using invite ID and participant ID
-     * Get participant invite
+     * Create project
      */
-    async apiInvitesIdParticipantInvitesParticipantIdGetRaw(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdGet().'
-            );
-        }
-
-        if (requestParameters['participantId'] == null) {
+    async apiProjectsPostRaw(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['apiProjectsPostRequest'] == null) {
             throw new runtime.RequiredError(
-                'participantId',
-                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdGet().'
+                'apiProjectsPostRequest',
+                'Required parameter "apiProjectsPostRequest" was null or undefined when calling apiProjectsPost().'
             );
         }
 
@@ -1963,6 +2030,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -1972,45 +2041,35 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participantInvites/{participantId}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
+        let urlPath = `/api/projects/`;
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ApiProjectsPostRequestToJSON(requestParameters['apiProjectsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Get a participant invite using invite ID and participant ID
-     * Get participant invite
+     * Create project
      */
-    async apiInvitesIdParticipantInvitesParticipantIdGet(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
-        const response = await this.apiInvitesIdParticipantInvitesParticipantIdGetRaw(requestParameters, initOverrides);
+    async apiProjectsPost(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update a participant invite using invite ID and participant ID
-     * Update participant invite
+     * Create project analysis
      */
-    async apiInvitesIdParticipantInvitesParticipantIdPutRaw(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdPut().'
-            );
-        }
-
-        if (requestParameters['participantId'] == null) {
+    async apiProjectsProjectIdAnalysisPostRaw(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'participantId',
-                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantInvitesParticipantIdPut().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdAnalysisPost().'
             );
         }
 
@@ -2018,8 +2077,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2029,46 +2086,39 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participantInvites/{participantId}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
+        let urlPath = `/api/projects/{projectId}/analysis`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdParticipantInvitesParticipantIdPutRequestToJSON(requestParameters['apiInvitesIdParticipantInvitesParticipantIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<any>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Update a participant invite using invite ID and participant ID
-     * Update participant invite
+     * Create project analysis
      */
-    async apiInvitesIdParticipantInvitesParticipantIdPut(requestParameters: ApiInvitesIdParticipantInvitesParticipantIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
-        const response = await this.apiInvitesIdParticipantInvitesParticipantIdPutRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdAnalysisPost(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
+        const response = await this.apiProjectsProjectIdAnalysisPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a participant invite using invite ID
-     * Create participant invite
+     * Delete or archive project
      */
-    async apiInvitesIdParticipantInvitesPostRaw(requestParameters: ApiInvitesIdParticipantInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantInvitesPost().'
-            );
-        }
-
-        if (requestParameters['apiInvitesIdParticipantInvitesPostRequest'] == null) {
+    async apiProjectsProjectIdDeletePostRaw(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesIdParticipantInvitesPostRequest',
-                'Required parameter "apiInvitesIdParticipantInvitesPostRequest" was null or undefined when calling apiInvitesIdParticipantInvitesPost().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdDeletePost().'
             );
         }
 
@@ -2076,8 +2126,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2087,44 +2135,648 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participantInvites`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/projects/{projectId}/delete`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdParticipantInvitesPostRequestToJSON(requestParameters['apiInvitesIdParticipantInvitesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Create a participant invite using invite ID
-     * Create participant invite
+     * Delete or archive project
+     */
+    async apiProjectsProjectIdDeletePost(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdDeletePostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Remove a file from a project
+     */
+    async apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
+            );
+        }
+
+        if (requestParameters['fileId'] == null) {
+            throw new runtime.RequiredError(
+                'fileId',
+                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/files/{fileId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace(`{${"fileId"}}`, encodeURIComponent(String(requestParameters['fileId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Remove a file from a project
+     */
+    async apiProjectsProjectIdFilesFileIdDelete(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Update project file metadata
+     */
+    async apiProjectsProjectIdFilesFileIdPutRaw(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
+            );
+        }
+
+        if (requestParameters['fileId'] == null) {
+            throw new runtime.RequiredError(
+                'fileId',
+                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/files/{fileId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace(`{${"fileId"}}`, encodeURIComponent(String(requestParameters['fileId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ApiProjectsProjectIdFilesFileIdPutRequestToJSON(requestParameters['apiProjectsProjectIdFilesFileIdPutRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
+    }
+
+    /**
+     * Update project file metadata
+     */
+    async apiProjectsProjectIdFilesFileIdPut(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
+        const response = await this.apiProjectsProjectIdFilesFileIdPutRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get files for a project
+     */
+    async apiProjectsProjectIdFilesGetRaw(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsProjectIdFilesGet200Response>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesGet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['category'] != null) {
+            queryParameters['category'] = requestParameters['category'];
+        }
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/files`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsProjectIdFilesGet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get files for a project
+     */
+    async apiProjectsProjectIdFilesGet(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsProjectIdFilesGet200Response> {
+        const response = await this.apiProjectsProjectIdFilesGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Add an existing file to a project
+     */
+    async apiProjectsProjectIdFilesPostRaw(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+            );
+        }
+
+        if (requestParameters['apiProjectsProjectIdFilesPostRequest'] == null) {
+            throw new runtime.RequiredError(
+                'apiProjectsProjectIdFilesPostRequest',
+                'Required parameter "apiProjectsProjectIdFilesPostRequest" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/files`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ApiProjectsProjectIdFilesPostRequestToJSON(requestParameters['apiProjectsProjectIdFilesPostRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
+    }
+
+    /**
+     * Add an existing file to a project
+     */
+    async apiProjectsProjectIdFilesPost(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
+        const response = await this.apiProjectsProjectIdFilesPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get project
+     */
+    async apiProjectsProjectIdGetRaw(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdGet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['includeThread'] != null) {
+            queryParameters['includeThread'] = requestParameters['includeThread'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get project
+     */
+    async apiProjectsProjectIdGet(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Launch project
+     */
+    async apiProjectsProjectIdLaunchPostRaw(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdLaunchPost().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/launch`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+    }
+
+    /**
+     * Launch project
+     */
+    async apiProjectsProjectIdLaunchPost(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdLaunchPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Update project
+     */
+    async apiProjectsProjectIdPutRaw(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdPut().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ApiProjectsProjectIdPutRequestToJSON(requestParameters['apiProjectsProjectIdPutRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+    }
+
+    /**
+     * Update project
+     */
+    async apiProjectsProjectIdPut(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdPutRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Search project transcripts
+     */
+    async apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SearchProjectTranscriptsResponse>> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdSearchTranscriptsPost().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/projects/{projectId}/searchTranscripts`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ApiProjectsProjectIdSearchTranscriptsPostRequestToJSON(requestParameters['apiProjectsProjectIdSearchTranscriptsPostRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SearchProjectTranscriptsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Search project transcripts
+     */
+    async apiProjectsProjectIdSearchTranscriptsPost(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SearchProjectTranscriptsResponse> {
+        const response = await this.apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get threads
+     */
+    async apiThreadsGetRaw(requestParameters: ApiThreadsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsGet200Response>> {
+        const queryParameters: any = {};
+
+        if (requestParameters['projectId'] != null) {
+            queryParameters['projectId'] = requestParameters['projectId'];
+        }
+
+        if (requestParameters['kind'] != null) {
+            queryParameters['kind'] = requestParameters['kind'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/threads/`;
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsGet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get threads
+     */
+    async apiThreadsGet(requestParameters: ApiThreadsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsGet200Response> {
+        const response = await this.apiThreadsGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get thread files
+     */
+    async apiThreadsThreadIdFilesGetRaw(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdFilesGet200Response>> {
+        if (requestParameters['threadId'] == null) {
+            throw new runtime.RequiredError(
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdFilesGet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+
+        if (requestParameters['fileNames'] != null) {
+            queryParameters['fileNames'] = requestParameters['fileNames'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/threads/{threadId}/files`;
+        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdFilesGet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get thread files
+     */
+    async apiThreadsThreadIdFilesGet(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdFilesGet200Response> {
+        const response = await this.apiThreadsThreadIdFilesGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Upsert thread
+     */
+    async apiThreadsThreadIdPostRaw(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Thread>> {
+        if (requestParameters['threadId'] == null) {
+            throw new runtime.RequiredError(
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdPost().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/threads/{threadId}`;
+        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ApiThreadsThreadIdPostRequestToJSON(requestParameters['apiThreadsThreadIdPostRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ThreadFromJSON(jsonValue));
+    }
+
+    /**
+     * Upsert thread
      */
-    async apiInvitesIdParticipantInvitesPost(requestParameters: ApiInvitesIdParticipantInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
-        const response = await this.apiInvitesIdParticipantInvitesPostRaw(requestParameters, initOverrides);
+    async apiThreadsThreadIdPost(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Thread> {
+        const response = await this.apiThreadsThreadIdPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get call metadata by invite ID and participant ID
+     * Get project brief versions from thread state history
      */
-    async apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['id'] == null) {
+    async apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
+        if (requestParameters['threadId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsGet().'
             );
         }
 
-        if (requestParameters['participantId'] == null) {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/threads/{threadId}/project-brief-versions`;
+        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get project brief versions from thread state history
+     */
+    async apiThreadsThreadIdProjectBriefVersionsGet(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
+        const response = await this.apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Create project draft versions from thread state history
+     */
+    async apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
+        if (requestParameters['threadId'] == null) {
             throw new runtime.RequiredError(
-                'participantId',
-                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsPost().'
             );
         }
 
@@ -2132,6 +2784,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2141,9 +2795,54 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participants/{participantId}/callMetadata`;
+        let urlPath = `/api/threads/{threadId}/project-brief-versions`;
+        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProjectBriefToJSON(requestParameters['projectBrief']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Create project draft versions from thread state history
+     */
+    async apiThreadsThreadIdProjectBriefVersionsPost(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
+        const response = await this.apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get user
+     */
+    async apiUsersIdGetRaw(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiUsersIdGet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/users/{id}`;
         urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -2152,32 +2851,171 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
+    }
+
+    /**
+     * Get user
+     */
+    async apiUsersIdGet(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
+        const response = await this.apiUsersIdGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiVapiWebhookPostRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/vapi/webhook`;
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiVapiWebhookPost(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiVapiWebhookPostRaw(initOverrides);
+    }
+
+    /**
+     * Create invite response for invite code
+     */
+    async createCodeInviteResponseRaw(requestParameters: CreateCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling createCodeInviteResponse().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['participantCode'] != null) {
+            queryParameters['participantCode'] = requestParameters['participantCode'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/inviteCode/{code}/responses`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateCodeInviteResponseRequestToJSON(requestParameters['createCodeInviteResponseRequest']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Create invite response for invite code
+     */
+    async createCodeInviteResponse(requestParameters: CreateCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createCodeInviteResponseRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Create invite response from existing response
+     */
+    async createCodeInviteResponseFromExistingRaw(requestParameters: CreateCodeInviteResponseFromExistingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling createCodeInviteResponseFromExisting().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling createCodeInviteResponseFromExisting().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/createNewResponse`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get call metadata by invite ID and participant ID
+     * Create invite response from existing response
      */
-    async apiInvitesIdParticipantsParticipantIdCallMetadataGet(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters, initOverrides);
+    async createCodeInviteResponseFromExisting(requestParameters: CreateCodeInviteResponseFromExistingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createCodeInviteResponseFromExistingRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update invite
+     * Add email access to a share
      */
-    async apiInvitesIdPutRaw(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Invite>> {
-        if (requestParameters['id'] == null) {
+    async createEmailShareRaw(requestParameters: CreateEmailShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmailShare>> {
+        if (requestParameters['shareEntityId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdPut().'
+                'shareEntityId',
+                'Required parameter "shareEntityId" was null or undefined when calling createEmailShare().'
             );
         }
 
-        if (requestParameters['apiInvitesIdPutRequest'] == null) {
+        if (requestParameters['createEmailShareRequest'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesIdPutRequest',
-                'Required parameter "apiInvitesIdPutRequest" was null or undefined when calling apiInvitesIdPut().'
+                'createEmailShareRequest',
+                'Required parameter "createEmailShareRequest" was null or undefined when calling createEmailShare().'
             );
         }
 
@@ -2196,56 +3034,45 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/sharing/share-entities/{shareEntityId}/emails`;
+        urlPath = urlPath.replace(`{${"shareEntityId"}}`, encodeURIComponent(String(requestParameters['shareEntityId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdPutRequestToJSON(requestParameters['apiInvitesIdPutRequest']),
+            body: CreateEmailShareRequestToJSON(requestParameters['createEmailShareRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmailShareFromJSON(jsonValue));
     }
 
     /**
-     * Update invite
+     * Add email access to a share
      */
-    async apiInvitesIdPut(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Invite> {
-        const response = await this.apiInvitesIdPutRaw(requestParameters, initOverrides);
+    async createEmailShare(requestParameters: CreateEmailShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailShare> {
+        const response = await this.createEmailShareRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all invite responses for an invite using invite ID
-     * Get invite responses
+     * Create a share link for a project
      */
-    async apiInvitesIdResponsesGetRaw(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiInvitesIdResponsesGet200Response>> {
-        if (requestParameters['id'] == null) {
+    async createProjectShareRaw(requestParameters: CreateProjectShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateProjectShareResponse>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesGet().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling createProjectShare().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
-        }
-
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-
-        if (requestParameters['statuses'] != null) {
-            queryParameters['statuses'] = requestParameters['statuses'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2255,45 +3082,53 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/sharing/projects/{projectId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CreateProjectShareRequestToJSON(requestParameters['createProjectShareRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInvitesIdResponsesGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CreateProjectShareResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get all invite responses for an invite using invite ID
-     * Get invite responses
+     * Create a share link for a project
      */
-    async apiInvitesIdResponsesGet(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiInvitesIdResponsesGet200Response> {
-        const response = await this.apiInvitesIdResponsesGetRaw(requestParameters, initOverrides);
+    async createProjectShare(requestParameters: CreateProjectShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateProjectShareResponse> {
+        const response = await this.createProjectShareRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create an invite response using invite ID
-     * Create invite response
+     * Create test invite for participant
      */
-    async apiInvitesIdResponsesPostRaw(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
-        if (requestParameters['id'] == null) {
+    async createTestParticipantCodeInviteRaw(requestParameters: CreateTestParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling createTestParticipantCodeInvite().'
+            );
+        }
+
+        if (requestParameters['participantCode'] == null) {
+            throw new runtime.RequiredError(
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling createTestParticipantCodeInvite().'
             );
         }
 
         const queryParameters: any = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['status'] != null) {
+            queryParameters['status'] = requestParameters['status'];
+        }
 
-        headerParameters['Content-Type'] = 'application/json';
+        const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -2304,44 +3139,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}/test`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
 
         const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdResponsesPostRequestToJSON(requestParameters['apiInvitesIdResponsesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create an invite response using invite ID
-     * Create invite response
+     * Create test invite for participant
      */
-    async apiInvitesIdResponsesPost(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesPostRaw(requestParameters, initOverrides);
+    async createTestParticipantCodeInvite(requestParameters: CreateTestParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createTestParticipantCodeInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get call metadata by invite ID and response ID
+     * Create transcript insight for invite response
      */
-    async apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['id'] == null) {
+    async createTranscriptInsightForCodeInviteResponseRaw(requestParameters: CreateTranscriptInsightForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling createTranscriptInsightForCodeInviteResponse().'
             );
         }
 
         if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
                 'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
+                'Required parameter "responseId" was null or undefined when calling createTranscriptInsightForCodeInviteResponse().'
             );
         }
 
@@ -2358,13 +3192,13 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses/{responseId}/callMetadata`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/transcriptInsight`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
         urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
@@ -2373,29 +3207,28 @@ export class DefaultApi extends runtime.BaseAPI {
     }
 
     /**
-     * Get call metadata by invite ID and response ID
+     * Create transcript insight for invite response
      */
-    async apiInvitesIdResponsesResponseIdCallMetadataGet(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters, initOverrides);
+    async createTranscriptInsightForCodeInviteResponse(requestParameters: CreateTranscriptInsightForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.createTranscriptInsightForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get an invite response using invite ID and response ID
-     * Get invite response
+     * Remove email access from a share
      */
-    async apiInvitesIdResponsesResponseIdGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
-        if (requestParameters['id'] == null) {
+    async deleteEmailShareRaw(requestParameters: DeleteEmailShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeleteEmailShare200Response>> {
+        if (requestParameters['shareEntityId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
+                'shareEntityId',
+                'Required parameter "shareEntityId" was null or undefined when calling deleteEmailShare().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
+        if (requestParameters['email'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
+                'email',
+                'Required parameter "email" was null or undefined when calling deleteEmailShare().'
             );
         }
 
@@ -2412,61 +3245,51 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses/{responseId}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/sharing/share-entities/{shareEntityId}/emails/{email}`;
+        urlPath = urlPath.replace(`{${"shareEntityId"}}`, encodeURIComponent(String(requestParameters['shareEntityId'])));
+        urlPath = urlPath.replace(`{${"email"}}`, encodeURIComponent(String(requestParameters['email'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => DeleteEmailShare200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get an invite response using invite ID and response ID
-     * Get invite response
+     * Remove email access from a share
      */
-    async apiInvitesIdResponsesResponseIdGet(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesResponseIdGetRaw(requestParameters, initOverrides);
+    async deleteEmailShare(requestParameters: DeleteEmailShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeleteEmailShare200Response> {
+        const response = await this.deleteEmailShareRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update an invite response using invite ID and response ID
-     * Update invite response
+     * Download invite responses as CSV
      */
-    async apiInvitesIdResponsesResponseIdPutRaw(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
+    async downloadInviteResponsesRaw(requestParameters: DownloadInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
         if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
                 'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
+                'Required parameter "id" was null or undefined when calling downloadInviteResponses().'
             );
         }
 
-        if (requestParameters['responseId'] == null) {
-            throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
-            );
-        }
+        const queryParameters: any = {};
 
-        if (requestParameters['apiInvitesIdResponsesResponseIdPutRequest'] == null) {
-            throw new runtime.RequiredError(
-                'apiInvitesIdResponsesResponseIdPutRequest',
-                'Required parameter "apiInvitesIdResponsesResponseIdPutRequest" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
-            );
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
         }
 
-        const queryParameters: any = {};
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2476,46 +3299,60 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses/{responseId}`;
+        let urlPath = `/api/invites/{id}/responses/download`;
         urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdResponsesResponseIdPutRequestToJSON(requestParameters['apiInvitesIdResponsesResponseIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Update an invite response using invite ID and response ID
-     * Update invite response
+     * Download invite responses as CSV
      */
-    async apiInvitesIdResponsesResponseIdPut(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesResponseIdPutRaw(requestParameters, initOverrides);
+    async downloadInviteResponses(requestParameters: DownloadInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadInviteResponsesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create invite
+     * Download invite responses as CSV
      */
-    async apiInvitesPostRaw(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Invite>> {
-        if (requestParameters['apiInvitesPostRequest'] == null) {
+    async downloadShareInviteResponsesRaw(requestParameters: DownloadShareInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesPostRequest',
-                'Required parameter "apiInvitesPostRequest" was null or undefined when calling apiInvitesPost().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling downloadShareInviteResponses().'
+            );
+        }
+
+        if (requestParameters['inviteId'] == null) {
+            throw new runtime.RequiredError(
+                'inviteId',
+                'Required parameter "inviteId" was null or undefined when calling downloadShareInviteResponses().'
             );
         }
 
         const queryParameters: any = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
+        }
 
-        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -2526,37 +3363,52 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/`;
+        let urlPath = `/api/share/{shareToken}/invites/{inviteId}/responses/download`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
+        urlPath = urlPath.replace(`{${"inviteId"}}`, encodeURIComponent(String(requestParameters['inviteId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesPostRequestToJSON(requestParameters['apiInvitesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Create invite
+     * Download invite responses as CSV
      */
-    async apiInvitesPost(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Invite> {
-        const response = await this.apiInvitesPostRaw(requestParameters, initOverrides);
+    async downloadShareInviteResponses(requestParameters: DownloadShareInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadShareInviteResponsesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get draft project
+     * Get call metadata for invite response
      */
-    async apiProjectsDraftGetRaw(requestParameters: ApiProjectsDraftGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Project>> {
-        const queryParameters: any = {};
+    async getCallMetadataForCodeInviteResponseRaw(requestParameters: GetCallMetadataForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling getCallMetadataForCodeInviteResponse().'
+            );
+        }
 
-        if (requestParameters['create'] != null) {
-            queryParameters['create'] = requestParameters['create'];
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCallMetadataForCodeInviteResponse().'
+            );
         }
 
+        const queryParameters: any = {};
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2568,7 +3420,9 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/draft`;
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/callMetadata`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -2577,37 +3431,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Get draft project
+     * Get call metadata for invite response
      */
-    async apiProjectsDraftGet(requestParameters: ApiProjectsDraftGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Project> {
-        const response = await this.apiProjectsDraftGetRaw(requestParameters, initOverrides);
+    async getCallMetadataForCodeInviteResponse(requestParameters: GetCallMetadataForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.getCallMetadataForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get projects
+     * Get invite by code
      */
-    async apiProjectsGetRaw(requestParameters: ApiProjectsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsGet200Response>> {
-        const queryParameters: any = {};
-
-        if (requestParameters['search'] != null) {
-            queryParameters['search'] = requestParameters['search'];
-        }
-
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
+    async getCodeInviteRaw(requestParameters: GetCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCodeInvite200Response>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInvite().'
+            );
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
+        const queryParameters: any = {};
 
-        if (requestParameters['statuses'] != null) {
-            queryParameters['statuses'] = requestParameters['statuses'];
+        if (requestParameters['participantCode'] != null) {
+            queryParameters['participantCode'] = requestParameters['participantCode'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -2621,7 +3470,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/`;
+        let urlPath = `/api/inviteCode/{code}/`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
@@ -2630,34 +3480,43 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCodeInvite200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get projects
+     * Get invite by code
      */
-    async apiProjectsGet(requestParameters: ApiProjectsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsGet200Response> {
-        const response = await this.apiProjectsGetRaw(requestParameters, initOverrides);
+    async getCodeInvite(requestParameters: GetCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCodeInvite200Response> {
+        const response = await this.getCodeInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project
+     * Get remaining responses count for participant
      */
-    async apiProjectsPostRaw(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['apiProjectsPostRequest'] == null) {
+    async getCodeInviteParticipantRemainingResponsesRaw(requestParameters: GetCodeInviteParticipantRemainingResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RemainingResponsesResponse>> {
+        if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
-                'apiProjectsPostRequest',
-                'Required parameter "apiProjectsPostRequest" was null or undefined when calling apiProjectsPost().'
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCodeInviteParticipantRemainingResponses().'
+            );
+        }
+
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteParticipantRemainingResponses().'
             );
         }
 
-        const queryParameters: any = {};
-
+        const queryParameters: any = {};
+
+        if (requestParameters['responseId'] != null) {
+            queryParameters['responseId'] = requestParameters['responseId'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2667,40 +3526,51 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/`;
+        let urlPath = `/api/inviteCode/{code}/remainingResponses`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsPostRequestToJSON(requestParameters['apiProjectsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RemainingResponsesResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create project
+     * Get remaining responses count for participant
      */
-    async apiProjectsPost(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsPostRaw(requestParameters, initOverrides);
+    async getCodeInviteParticipantRemainingResponses(requestParameters: GetCodeInviteParticipantRemainingResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RemainingResponsesResponse> {
+        const response = await this.getCodeInviteParticipantRemainingResponsesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project analysis
+     * Get invite response for participant
      */
-    async apiProjectsProjectIdAnalysisPostRaw(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeInviteParticipantResponseRaw(requestParameters: GetCodeInviteParticipantResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['participantCode'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdAnalysisPost().'
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling getCodeInviteParticipantResponse().'
+            );
+        }
+
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteParticipantResponse().'
             );
         }
 
         const queryParameters: any = {};
 
+        if (requestParameters['participantCode'] != null) {
+            queryParameters['participantCode'] = requestParameters['participantCode'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2712,39 +3582,42 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/analysis`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/inviteCode/{code}/participantResponse`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse<any>(response);
-        } else {
-            return new runtime.TextApiResponse(response) as any;
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create project analysis
+     * Get invite response for participant
      */
-    async apiProjectsProjectIdAnalysisPost(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
-        const response = await this.apiProjectsProjectIdAnalysisPostRaw(requestParameters, initOverrides);
+    async getCodeInviteParticipantResponse(requestParameters: GetCodeInviteParticipantResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.getCodeInviteParticipantResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Delete or archive project
+     * Get invite response
      */
-    async apiProjectsProjectIdDeletePostRaw(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeInviteResponseRaw(requestParameters: GetCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdDeletePost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCodeInviteResponse().'
             );
         }
 
@@ -2761,42 +3634,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/delete`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Delete or archive project
+     * Get invite response
      */
-    async apiProjectsProjectIdDeletePost(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdDeletePostRaw(requestParameters, initOverrides);
+    async getCodeInviteResponse(requestParameters: GetCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.getCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Remove a file from a project
+     * Get redirect URL for invite response
      */
-    async apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeInviteResponseRedirectRaw(requestParameters: GetCodeInviteResponseRedirectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCodeInviteResponseRedirect200Response>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteResponseRedirect().'
             );
         }
 
-        if (requestParameters['fileId'] == null) {
+        if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
-                'fileId',
-                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCodeInviteResponseRedirect().'
             );
         }
 
@@ -2813,42 +3687,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files/{fileId}`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
-        urlPath = urlPath.replace(`{${"fileId"}}`, encodeURIComponent(String(requestParameters['fileId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/redirect`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'DELETE',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCodeInviteResponseRedirect200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Remove a file from a project
+     * Get redirect URL for invite response
      */
-    async apiProjectsProjectIdFilesFileIdDelete(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters, initOverrides);
+    async getCodeInviteResponseRedirect(requestParameters: GetCodeInviteResponseRedirectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCodeInviteResponseRedirect200Response> {
+        const response = await this.getCodeInviteResponseRedirectRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Update project file metadata
+     * Get participant invite for invite code
      */
-    async apiProjectsProjectIdFilesFileIdPutRaw(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeParticipantInviteRaw(requestParameters: GetCodeParticipantInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeParticipantInvite().'
             );
         }
 
-        if (requestParameters['fileId'] == null) {
+        if (requestParameters['participantCode'] == null) {
             throw new runtime.RequiredError(
-                'fileId',
-                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling getCodeParticipantInvite().'
             );
         }
 
@@ -2856,8 +3731,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2867,54 +3740,34 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files/{fileId}`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
-        urlPath = urlPath.replace(`{${"fileId"}}`, encodeURIComponent(String(requestParameters['fileId'])));
+        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdFilesFileIdPutRequestToJSON(requestParameters['apiProjectsProjectIdFilesFileIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
     }
 
     /**
-     * Update project file metadata
+     * Get participant invite for invite code
      */
-    async apiProjectsProjectIdFilesFileIdPut(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
-        const response = await this.apiProjectsProjectIdFilesFileIdPutRaw(requestParameters, initOverrides);
+    async getCodeParticipantInvite(requestParameters: GetCodeParticipantInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
+        const response = await this.getCodeParticipantInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get files for a project
+     * List all share entities created by the user
      */
-    async apiProjectsProjectIdFilesGetRaw(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsProjectIdFilesGet200Response>> {
-        if (requestParameters['projectId'] == null) {
-            throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesGet().'
-            );
-        }
-
+    async getShareEntitiesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetShareEntities200Response>> {
         const queryParameters: any = {};
 
-        if (requestParameters['category'] != null) {
-            queryParameters['category'] = requestParameters['category'];
-        }
-
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
-        }
-
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2926,8 +3779,7 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/sharing/share-entities`;
 
         const response = await this.request({
             path: urlPath,
@@ -2936,32 +3788,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsProjectIdFilesGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetShareEntities200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get files for a project
+     * List all share entities created by the user
      */
-    async apiProjectsProjectIdFilesGet(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsProjectIdFilesGet200Response> {
-        const response = await this.apiProjectsProjectIdFilesGetRaw(requestParameters, initOverrides);
+    async getShareEntities(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetShareEntities200Response> {
+        const response = await this.getShareEntitiesRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Add an existing file to a project
+     * Get shared call data with conversation messages
      */
-    async apiProjectsProjectIdFilesPostRaw(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
-        if (requestParameters['projectId'] == null) {
+    async getSharedCallRaw(requestParameters: GetSharedCallRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Call>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling getSharedCall().'
             );
         }
 
-        if (requestParameters['apiProjectsProjectIdFilesPostRequest'] == null) {
+        if (requestParameters['callId'] == null) {
             throw new runtime.RequiredError(
-                'apiProjectsProjectIdFilesPostRequest',
-                'Required parameter "apiProjectsProjectIdFilesPostRequest" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+                'callId',
+                'Required parameter "callId" was null or undefined when calling getSharedCall().'
             );
         }
 
@@ -2969,8 +3821,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -2980,45 +3830,55 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/share/{shareToken}/calls/{callId}`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
+        urlPath = urlPath.replace(`{${"callId"}}`, encodeURIComponent(String(requestParameters['callId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdFilesPostRequestToJSON(requestParameters['apiProjectsProjectIdFilesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallFromJSON(jsonValue));
     }
 
     /**
-     * Add an existing file to a project
+     * Get shared call data with conversation messages
      */
-    async apiProjectsProjectIdFilesPost(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
-        const response = await this.apiProjectsProjectIdFilesPostRaw(requestParameters, initOverrides);
+    async getSharedCall(requestParameters: GetSharedCallRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Call> {
+        const response = await this.getSharedCallRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project
+     * Get shared call metadata by invite ID and response ID
      */
-    async apiProjectsProjectIdGetRaw(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getSharedCallMetadataRaw(requestParameters: GetSharedCallMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdGet().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling getSharedCallMetadata().'
             );
         }
 
-        const queryParameters: any = {};
+        if (requestParameters['inviteId'] == null) {
+            throw new runtime.RequiredError(
+                'inviteId',
+                'Required parameter "inviteId" was null or undefined when calling getSharedCallMetadata().'
+            );
+        }
 
-        if (requestParameters['includeThread'] != null) {
-            queryParameters['includeThread'] = requestParameters['includeThread'];
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getSharedCallMetadata().'
+            );
         }
 
+        const queryParameters: any = {};
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -3030,8 +3890,10 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/share/{shareToken}/invites/{inviteId}/responses/{responseId}/callMetadata`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
+        urlPath = urlPath.replace(`{${"inviteId"}}`, encodeURIComponent(String(requestParameters['inviteId'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3040,30 +3902,45 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Get project
+     * Get shared call metadata by invite ID and response ID
      */
-    async apiProjectsProjectIdGet(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdGetRaw(requestParameters, initOverrides);
+    async getSharedCallMetadata(requestParameters: GetSharedCallMetadataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.getSharedCallMetadataRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Launch project
+     * Get attribute stats for shared invite responses
      */
-    async apiProjectsProjectIdLaunchPostRaw(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getSharedInviteResponseAttributeStatsRaw(requestParameters: GetSharedInviteResponseAttributeStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AttributeStatsSchemaInner>>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdLaunchPost().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling getSharedInviteResponseAttributeStats().'
+            );
+        }
+
+        if (requestParameters['inviteId'] == null) {
+            throw new runtime.RequiredError(
+                'inviteId',
+                'Required parameter "inviteId" was null or undefined when calling getSharedInviteResponseAttributeStats().'
             );
         }
 
         const queryParameters: any = {};
 
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
+        }
+
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -3075,44 +3952,66 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/launch`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/share/{shareToken}/invites/{inviteId}/response-attribute-stats`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
+        urlPath = urlPath.replace(`{${"inviteId"}}`, encodeURIComponent(String(requestParameters['inviteId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AttributeStatsSchemaInnerFromJSON));
     }
 
     /**
-     * Launch project
+     * Get attribute stats for shared invite responses
      */
-    async apiProjectsProjectIdLaunchPost(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdLaunchPostRaw(requestParameters, initOverrides);
+    async getSharedInviteResponseAttributeStats(requestParameters: GetSharedInviteResponseAttributeStatsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AttributeStatsSchemaInner>> {
+        const response = await this.getSharedInviteResponseAttributeStatsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update project
+     * Get responses for a shared invite
      */
-    async apiProjectsProjectIdPutRaw(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getSharedInviteResponsesRaw(requestParameters: GetSharedInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSharedInviteResponses200Response>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdPut().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling getSharedInviteResponses().'
+            );
+        }
+
+        if (requestParameters['inviteId'] == null) {
+            throw new runtime.RequiredError(
+                'inviteId',
+                'Required parameter "inviteId" was null or undefined when calling getSharedInviteResponses().'
             );
         }
 
-        const queryParameters: any = {};
-
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['statuses'] != null) {
+            queryParameters['statuses'] = requestParameters['statuses'];
+        }
+
+        if (requestParameters['filters'] != null) {
+            queryParameters['filters'] = requestParameters['filters'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3122,45 +4021,41 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/share/{shareToken}/invites/{inviteId}/responses`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
+        urlPath = urlPath.replace(`{${"inviteId"}}`, encodeURIComponent(String(requestParameters['inviteId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdPutRequestToJSON(requestParameters['apiProjectsProjectIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetSharedInviteResponses200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Update project
+     * Get responses for a shared invite
      */
-    async apiProjectsProjectIdPut(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdPutRaw(requestParameters, initOverrides);
+    async getSharedInviteResponses(requestParameters: GetSharedInviteResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSharedInviteResponses200Response> {
+        const response = await this.getSharedInviteResponsesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project response attribute stats
+     * Get shared project data
      */
-    async apiProjectsProjectIdResponseAttributeStatsGetRaw(requestParameters: ApiProjectsProjectIdResponseAttributeStatsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AttributeStatsSchemaInner>>> {
-        if (requestParameters['projectId'] == null) {
+    async getSharedProjectRaw(requestParameters: GetSharedProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['shareToken'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdResponseAttributeStatsGet().'
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling getSharedProject().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['inviteId'] != null) {
-            queryParameters['inviteId'] = requestParameters['inviteId'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -3172,8 +4067,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/responseAttributeStats`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/share/{shareToken}/project`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3182,44 +4077,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AttributeStatsSchemaInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Get project response attribute stats
+     * Get shared project data
      */
-    async apiProjectsProjectIdResponseAttributeStatsGet(requestParameters: ApiProjectsProjectIdResponseAttributeStatsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AttributeStatsSchemaInner>> {
-        const response = await this.apiProjectsProjectIdResponseAttributeStatsGetRaw(requestParameters, initOverrides);
+    async getSharedProject(requestParameters: GetSharedProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.getSharedProjectRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project responses
+     * Join invite by code
      */
-    async apiProjectsProjectIdResponsesGetRaw(requestParameters: ApiProjectsProjectIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetProjectResponsesResponse>> {
-        if (requestParameters['projectId'] == null) {
+    async joinCodeInviteRaw(requestParameters: JoinCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdResponsesGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling joinCodeInvite().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
-        }
-
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-
-        if (requestParameters['inviteId'] != null) {
-            queryParameters['inviteId'] = requestParameters['inviteId'];
-        }
-
-        if (requestParameters['filters'] != null) {
-            queryParameters['filters'] = requestParameters['filters'];
+        if (requestParameters['rdud'] != null) {
+            queryParameters['rdud'] = requestParameters['rdud'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -3233,8 +4116,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/responses`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/inviteCode/{code}/join`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3243,25 +4126,31 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GetProjectResponsesResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get project responses
+     * Join invite by code
      */
-    async apiProjectsProjectIdResponsesGet(requestParameters: ApiProjectsProjectIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetProjectResponsesResponse> {
-        const response = await this.apiProjectsProjectIdResponsesGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async joinCodeInvite(requestParameters: JoinCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.joinCodeInviteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Search project transcripts
+     * Join invite by code and participant code
      */
-    async apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SearchProjectTranscriptsResponse>> {
-        if (requestParameters['projectId'] == null) {
+    async joinParticipantCodeInviteRaw(requestParameters: JoinParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdSearchTranscriptsPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling joinParticipantCodeInvite().'
+            );
+        }
+
+        if (requestParameters['participantCode'] == null) {
+            throw new runtime.RequiredError(
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling joinParticipantCodeInvite().'
             );
         }
 
@@ -3269,8 +4158,6 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3280,52 +4167,51 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/searchTranscripts`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/inviteCode/{code}/participantCode/{participantCode}/start`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"participantCode"}}`, encodeURIComponent(String(requestParameters['participantCode'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdSearchTranscriptsPostRequestToJSON(requestParameters['apiProjectsProjectIdSearchTranscriptsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SearchProjectTranscriptsResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Search project transcripts
+     * Join invite by code and participant code
      */
-    async apiProjectsProjectIdSearchTranscriptsPost(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SearchProjectTranscriptsResponse> {
-        const response = await this.apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters, initOverrides);
-        return await response.value();
+    async joinParticipantCodeInvite(requestParameters: JoinParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.joinParticipantCodeInviteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get threads
+     * Request access to a share by email
      */
-    async apiThreadsGetRaw(requestParameters: ApiThreadsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsGet200Response>> {
-        const queryParameters: any = {};
-
-        if (requestParameters['projectId'] != null) {
-            queryParameters['projectId'] = requestParameters['projectId'];
-        }
-
-        if (requestParameters['kind'] != null) {
-            queryParameters['kind'] = requestParameters['kind'];
+    async requestShareAccessRaw(requestParameters: RequestShareAccessOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RequestShareAccess200Response>> {
+        if (requestParameters['shareToken'] == null) {
+            throw new runtime.RequiredError(
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling requestShareAccess().'
+            );
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
+        if (requestParameters['requestShareAccessRequest'] == null) {
+            throw new runtime.RequiredError(
+                'requestShareAccessRequest',
+                'Required parameter "requestShareAccessRequest" was null or undefined when calling requestShareAccess().'
+            );
         }
 
-        if (requestParameters['offset'] != null) {
-            queryParameters['offset'] = requestParameters['offset'];
-        }
+        const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3335,50 +4221,47 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/`;
+        let urlPath = `/api/share/{shareToken}/request-access`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: RequestShareAccessRequestToJSON(requestParameters['requestShareAccessRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RequestShareAccess200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get threads
+     * Request access to a share by email
      */
-    async apiThreadsGet(requestParameters: ApiThreadsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsGet200Response> {
-        const response = await this.apiThreadsGetRaw(requestParameters, initOverrides);
+    async requestShareAccess(requestParameters: RequestShareAccessOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RequestShareAccess200Response> {
+        const response = await this.requestShareAccessRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get thread files
+     * Start call for invite response
      */
-    async apiThreadsThreadIdFilesGetRaw(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdFilesGet200Response>> {
-        if (requestParameters['threadId'] == null) {
+    async startCallForCodeInviteResponseRaw(requestParameters: StartCallForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InboundCallResponse>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'threadId',
-                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdFilesGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling startCallForCodeInviteResponse().'
             );
         }
 
-        const queryParameters: any = {};
-
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-
-        if (requestParameters['offset'] != null) {
-            queryParameters['offset'] = requestParameters['offset'];
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling startCallForCodeInviteResponse().'
+            );
         }
 
-        if (requestParameters['fileNames'] != null) {
-            queryParameters['fileNames'] = requestParameters['fileNames'];
-        }
+        const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -3391,8 +4274,9 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/{threadId}/files`;
-        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/startCall`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3401,25 +4285,39 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdFilesGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => InboundCallResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get thread files
+     * Start call for invite response
      */
-    async apiThreadsThreadIdFilesGet(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdFilesGet200Response> {
-        const response = await this.apiThreadsThreadIdFilesGetRaw(requestParameters, initOverrides);
+    async startCallForCodeInviteResponse(requestParameters: StartCallForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InboundCallResponse> {
+        const response = await this.startCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Upsert thread
+     * Start phone call for invite response
      */
-    async apiThreadsThreadIdPostRaw(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Thread>> {
-        if (requestParameters['threadId'] == null) {
+    async startPhoneCallForCodeInviteResponseRaw(requestParameters: StartPhoneCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PhoneCallStartResponse>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'threadId',
-                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling startPhoneCallForCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling startPhoneCallForCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['startPhoneCallForCodeInviteResponseRequest'] == null) {
+            throw new runtime.RequiredError(
+                'startPhoneCallForCodeInviteResponseRequest',
+                'Required parameter "startPhoneCallForCodeInviteResponseRequest" was null or undefined when calling startPhoneCallForCodeInviteResponse().'
             );
         }
 
@@ -3438,36 +4336,51 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/{threadId}`;
-        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/startPhoneCall`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiThreadsThreadIdPostRequestToJSON(requestParameters['apiThreadsThreadIdPostRequest']),
+            body: StartPhoneCallForCodeInviteResponseRequestToJSON(requestParameters['startPhoneCallForCodeInviteResponseRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ThreadFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PhoneCallStartResponseFromJSON(jsonValue));
     }
 
     /**
-     * Upsert thread
+     * Start phone call for invite response
      */
-    async apiThreadsThreadIdPost(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Thread> {
-        const response = await this.apiThreadsThreadIdPostRaw(requestParameters, initOverrides);
+    async startPhoneCallForCodeInviteResponse(requestParameters: StartPhoneCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PhoneCallStartResponse> {
+        const response = await this.startPhoneCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project brief versions from thread state history
+     * Update call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
-        if (requestParameters['threadId'] == null) {
+    async updateCallForCodeInviteResponseRaw(requestParameters: UpdateCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'threadId',
-                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling updateCallForCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling updateCallForCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['updateCallForCodeInviteResponseRequest'] == null) {
+            throw new runtime.RequiredError(
+                'updateCallForCodeInviteResponseRequest',
+                'Required parameter "updateCallForCodeInviteResponseRequest" was null or undefined when calling updateCallForCodeInviteResponse().'
             );
         }
 
@@ -3475,6 +4388,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3484,35 +4399,48 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/{threadId}/project-brief-versions`;
-        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}/updateCall`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
+            body: UpdateCallForCodeInviteResponseRequestToJSON(requestParameters['updateCallForCodeInviteResponseRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<any>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Get project brief versions from thread state history
+     * Update call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsGet(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
-        const response = await this.apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters, initOverrides);
+    async updateCallForCodeInviteResponse(requestParameters: UpdateCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
+        const response = await this.updateCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project draft versions from thread state history
+     * Update invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
-        if (requestParameters['threadId'] == null) {
+    async updateCodeInviteResponseRaw(requestParameters: UpdateCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CodeInviteResponse>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'threadId',
-                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling updateCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling updateCodeInviteResponse().'
             );
         }
 
@@ -3531,36 +4459,37 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/{threadId}/project-brief-versions`;
-        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+        let urlPath = `/api/inviteCode/{code}/responses/{responseId}`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'POST',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: ProjectBriefToJSON(requestParameters['projectBrief']),
+            body: InviteResponseUpdateEventToJSON(requestParameters['inviteResponseUpdateEvent']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create project draft versions from thread state history
+     * Update invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsPost(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
-        const response = await this.apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters, initOverrides);
+    async updateCodeInviteResponse(requestParameters: UpdateCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.updateCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get user
+     * Update a share entity
      */
-    async apiUsersIdGetRaw(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters['id'] == null) {
+    async updateShareEntityRaw(requestParameters: UpdateShareEntityOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShareEntity>> {
+        if (requestParameters['shareEntityId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiUsersIdGet().'
+                'shareEntityId',
+                'Required parameter "shareEntityId" was null or undefined when calling updateShareEntity().'
             );
         }
 
@@ -3568,6 +4497,8 @@ export class DefaultApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3577,34 +4508,52 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/users/{id}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/sharing/share-entities/{shareEntityId}`;
+        urlPath = urlPath.replace(`{${"shareEntityId"}}`, encodeURIComponent(String(requestParameters['shareEntityId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
+            body: UpdateShareEntityRequestToJSON(requestParameters['updateShareEntityRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ShareEntityFromJSON(jsonValue));
     }
 
     /**
-     * Get user
+     * Update a share entity
      */
-    async apiUsersIdGet(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
-        const response = await this.apiUsersIdGetRaw(requestParameters, initOverrides);
+    async updateShareEntity(requestParameters: UpdateShareEntityOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShareEntity> {
+        const response = await this.updateShareEntityRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * Verify email access for a share
      */
-    async apiVapiWebhookPostRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async verifyEmailAccessForShareRaw(requestParameters: VerifyEmailAccessForShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VerifyEmailAccessForShare200Response>> {
+        if (requestParameters['shareToken'] == null) {
+            throw new runtime.RequiredError(
+                'shareToken',
+                'Required parameter "shareToken" was null or undefined when calling verifyEmailAccessForShare().'
+            );
+        }
+
+        if (requestParameters['verifyEmailAccessForShareRequest'] == null) {
+            throw new runtime.RequiredError(
+                'verifyEmailAccessForShareRequest',
+                'Required parameter "verifyEmailAccessForShareRequest" was null or undefined when calling verifyEmailAccessForShare().'
+            );
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -3614,22 +4563,26 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/vapi/webhook`;
+        let urlPath = `/api/share/{shareToken}/verify`;
+        urlPath = urlPath.replace(`{${"shareToken"}}`, encodeURIComponent(String(requestParameters['shareToken'])));
 
         const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: VerifyEmailAccessForShareRequestToJSON(requestParameters['verifyEmailAccessForShareRequest']),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => VerifyEmailAccessForShare200ResponseFromJSON(jsonValue));
     }
 
     /**
+     * Verify email access for a share
      */
-    async apiVapiWebhookPost(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiVapiWebhookPostRaw(initOverrides);
+    async verifyEmailAccessForShare(requestParameters: VerifyEmailAccessForShareOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VerifyEmailAccessForShare200Response> {
+        const response = await this.verifyEmailAccessForShareRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }