keplar-api 0.0.8 → 0.0.10

package/src/apis/DefaultApi.ts

@@ -19,12 +19,7 @@ import type {
   ApiDemosCreateDemoInvitePostRequest,
   ApiFilesFileIdSignedUrlPost200Response,
   ApiFilesFileIdSignedUrlPostRequest,
-  ApiInviteCodeCodeGet200Response,
-  ApiInviteCodeCodeResponsesResponseIdPut404Response,
-  ApiInviteCodeCodeResponsesResponseIdRedirectGet200Response,
-  ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequest,
-  ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequest,
-  ApiInviteCodeCodeStartGet302Response,
+  ApiInvitesIdParticipantInvitesGet200Response,
   ApiInvitesIdParticipantInvitesParticipantIdPutRequest,
   ApiInvitesIdParticipantInvitesPostRequest,
   ApiInvitesIdPutRequest,
@@ -43,18 +38,21 @@ import type {
   ApiThreadsThreadIdFilesGet200Response,
   ApiThreadsThreadIdPostRequest,
   ApiThreadsThreadIdProjectBriefVersionsGet200Response,
+  AttributeStatsSchemaInner,
   BadRequestErrorResponse,
   Call,
   CallMetadata,
   CodeInviteResponse,
   ConversationMessage,
-  GetParticipantInvitesResponse,
-  GetProjectResponsesResponse,
+  CreateCodeInviteResponseRequest,
+  GetCodeInvite200Response,
+  GetCodeInviteResponseRedirect200Response,
   InboundCallResponse,
-  Invite,
   InviteResponse,
   InviteResponseStatus,
   InviteResponseUpdateEvent,
+  InviteWithAnalytics,
+  JoinCodeInvite302Response,
   ModelFile,
   NotFoundErrorResponse,
   ParticipantInvite,
@@ -66,8 +64,11 @@ import type {
   ProjectWithAnalytics,
   RemainingResponsesResponse,
   SearchProjectTranscriptsResponse,
+  StartPhoneCallForCodeInviteResponseRequest,
   Thread,
   ThreadKind,
+  UpdateCallForCodeInviteResponseRequest,
+  UpdateCodeInviteResponse404Response,
   User,
 } from '../models/index';
 import {
@@ -79,18 +80,8 @@ import {
     ApiFilesFileIdSignedUrlPost200ResponseToJSON,
     ApiFilesFileIdSignedUrlPostRequestFromJSON,
     ApiFilesFileIdSignedUrlPostRequestToJSON,
-    ApiInviteCodeCodeGet200ResponseFromJSON,
-    ApiInviteCodeCodeGet200ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdPut404ResponseFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdPut404ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseToJSON,
-    ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequestFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdStartPhoneCallPostRequestToJSON,
-    ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequestFromJSON,
-    ApiInviteCodeCodeResponsesResponseIdUpdateCallPutRequestToJSON,
-    ApiInviteCodeCodeStartGet302ResponseFromJSON,
-    ApiInviteCodeCodeStartGet302ResponseToJSON,
+    ApiInvitesIdParticipantInvitesGet200ResponseFromJSON,
+    ApiInvitesIdParticipantInvitesGet200ResponseToJSON,
     ApiInvitesIdParticipantInvitesParticipantIdPutRequestFromJSON,
     ApiInvitesIdParticipantInvitesParticipantIdPutRequestToJSON,
     ApiInvitesIdParticipantInvitesPostRequestFromJSON,
@@ -127,6 +118,8 @@ import {
     ApiThreadsThreadIdPostRequestToJSON,
     ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON,
     ApiThreadsThreadIdProjectBriefVersionsGet200ResponseToJSON,
+    AttributeStatsSchemaInnerFromJSON,
+    AttributeStatsSchemaInnerToJSON,
     BadRequestErrorResponseFromJSON,
     BadRequestErrorResponseToJSON,
     CallFromJSON,
@@ -137,20 +130,24 @@ import {
     CodeInviteResponseToJSON,
     ConversationMessageFromJSON,
     ConversationMessageToJSON,
-    GetParticipantInvitesResponseFromJSON,
-    GetParticipantInvitesResponseToJSON,
-    GetProjectResponsesResponseFromJSON,
-    GetProjectResponsesResponseToJSON,
+    CreateCodeInviteResponseRequestFromJSON,
+    CreateCodeInviteResponseRequestToJSON,
+    GetCodeInvite200ResponseFromJSON,
+    GetCodeInvite200ResponseToJSON,
+    GetCodeInviteResponseRedirect200ResponseFromJSON,
+    GetCodeInviteResponseRedirect200ResponseToJSON,
     InboundCallResponseFromJSON,
     InboundCallResponseToJSON,
-    InviteFromJSON,
-    InviteToJSON,
     InviteResponseFromJSON,
     InviteResponseToJSON,
     InviteResponseStatusFromJSON,
     InviteResponseStatusToJSON,
     InviteResponseUpdateEventFromJSON,
     InviteResponseUpdateEventToJSON,
+    InviteWithAnalyticsFromJSON,
+    InviteWithAnalyticsToJSON,
+    JoinCodeInvite302ResponseFromJSON,
+    JoinCodeInvite302ResponseToJSON,
     ModelFileFromJSON,
     ModelFileToJSON,
     NotFoundErrorResponseFromJSON,
@@ -173,10 +170,16 @@ import {
     RemainingResponsesResponseToJSON,
     SearchProjectTranscriptsResponseFromJSON,
     SearchProjectTranscriptsResponseToJSON,
+    StartPhoneCallForCodeInviteResponseRequestFromJSON,
+    StartPhoneCallForCodeInviteResponseRequestToJSON,
     ThreadFromJSON,
     ThreadToJSON,
     ThreadKindFromJSON,
     ThreadKindToJSON,
+    UpdateCallForCodeInviteResponseRequestFromJSON,
+    UpdateCallForCodeInviteResponseRequestToJSON,
+    UpdateCodeInviteResponse404ResponseFromJSON,
+    UpdateCodeInviteResponse404ResponseToJSON,
     UserFromJSON,
     UserToJSON,
 } from '../models/index';
@@ -211,88 +214,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 {
@@ -301,6 +229,8 @@ export interface ApiInvitesIdGetRequest {
 
 export interface ApiInvitesIdParticipantInvitesGetRequest {
     id: string;
+    page?: number;
+    limit?: number;
 }
 
 export interface ApiInvitesIdParticipantInvitesParticipantIdGetRequest {
@@ -329,11 +259,16 @@ export interface ApiInvitesIdPutOperationRequest {
     apiInvitesIdPutRequest: ApiInvitesIdPutRequest;
 }
 
+export interface ApiInvitesIdResponseAttributeStatsGetRequest {
+    id: string;
+}
+
 export interface ApiInvitesIdResponsesGetRequest {
     id: string;
     page?: number;
     limit?: number;
     statuses?: Array<InviteResponseStatus>;
+    filters?: string;
 }
 
 export interface ApiInvitesIdResponsesPostOperationRequest {
@@ -421,12 +356,6 @@ export interface ApiProjectsProjectIdPutOperationRequest {
     apiProjectsProjectIdPutRequest?: ApiProjectsProjectIdPutRequest;
 }
 
-export interface ApiProjectsProjectIdResponsesGetRequest {
-    projectId: string;
-    page?: number;
-    limit?: number;
-}
-
 export interface ApiProjectsProjectIdSearchTranscriptsPostOperationRequest {
     projectId: string;
     apiProjectsProjectIdSearchTranscriptsPostRequest?: ApiProjectsProjectIdSearchTranscriptsPostRequest;
@@ -464,6 +393,96 @@ export interface ApiUsersIdGetRequest {
     id: string;
 }
 
+export interface CreateCodeInviteResponseOperationRequest {
+    code: string;
+    participantCode?: string;
+    createCodeInviteResponseRequest?: CreateCodeInviteResponseRequest;
+}
+
+export interface CreateCodeInviteResponseFromExistingRequest {
+    code: string;
+    responseId: string;
+}
+
+export interface CreateTestParticipantCodeInviteRequest {
+    code: string;
+    participantCode: string;
+    status?: InviteResponseStatus;
+}
+
+export interface CreateTranscriptInsightForCodeInviteResponseRequest {
+    code: string;
+    responseId: 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 JoinCodeInviteRequest {
+    code: string;
+    rdud?: string | null;
+}
+
+export interface JoinParticipantCodeInviteRequest {
+    code: string;
+    participantCode: string;
+}
+
+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;
+}
+
 /**
  * 
  */
@@ -932,23 +951,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) {
@@ -960,8 +980,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,
@@ -970,34 +991,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().'
             );
         }
 
@@ -1014,9 +1023,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,
@@ -1025,34 +1033,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().'
             );
         }
 
@@ -1069,9 +1066,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,
@@ -1080,40 +1076,37 @@ 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'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -1127,54 +1120,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) {
@@ -1186,8 +1174,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,
@@ -1196,45 +1185,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", []);
@@ -1244,44 +1231,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().'
             );
         }
 
@@ -1289,6 +1278,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", []);
@@ -1298,45 +1289,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().'
             );
         }
 
@@ -1353,45 +1343,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().'
             );
         }
 
@@ -1399,6 +1387,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", []);
@@ -1408,45 +1398,36 @@ 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) {
-            throw new runtime.RequiredError(
-                'code',
-                'Required parameter "code" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdPut().'
-            );
-        }
-
-        if (requestParameters['responseId'] == null) {
+    async apiInvitesIdResponseAttributeStatsGetRaw(requestParameters: ApiInvitesIdResponseAttributeStatsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AttributeStatsSchemaInner>>> {
+        if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInviteCodeCodeResponsesResponseIdPut().'
+                'id',
+                'Required parameter "id" was null or undefined when calling apiInvitesIdResponseAttributeStatsGet().'
             );
         }
 
@@ -1454,8 +1435,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", []);
@@ -1465,50 +1444,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<ApiInvitesIdResponsesGet200Response>> {
+        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 = {};
 
@@ -1521,9 +1506,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,
@@ -1532,34 +1516,27 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInviteCodeCodeResponsesResponseIdRedirectGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInvitesIdResponsesGet200ResponseFromJSON(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<ApiInvitesIdResponsesGet200Response> {
+        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().'
             );
         }
 
@@ -1567,6 +1544,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", []);
@@ -1576,52 +1555,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().'
             );
         }
 
@@ -1629,8 +1600,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", []);
@@ -1640,46 +1609,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().'
             );
         }
 
@@ -1696,52 +1663,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().'
             );
         }
 
@@ -1760,8 +1727,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({
@@ -1769,45 +1736,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", []);
@@ -1817,40 +1777,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) {
@@ -1862,8 +1819,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,
@@ -1872,30 +1828,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 = {};
 
@@ -1908,8 +1872,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,
@@ -1918,34 +1881,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().'
             );
         }
 
@@ -1953,6 +1907,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", []);
@@ -1962,45 +1918,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().'
             );
         }
 
@@ -2008,8 +1954,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", []);
@@ -2019,46 +1963,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().'
             );
         }
 
@@ -2066,8 +2003,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", []);
@@ -2077,44 +2012,42 @@ 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 apiInvitesIdParticipantInvitesPost(requestParameters: ApiInvitesIdParticipantInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
-        const response = await this.apiInvitesIdParticipantInvitesPostRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdDeletePost(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdDeletePostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get call metadata by invite ID and participant ID
+     * Remove a file from a project
      */
-    async apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['id'] == null) {
+    async apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
             );
         }
 
-        if (requestParameters['participantId'] == null) {
+        if (requestParameters['fileId'] == null) {
             throw new runtime.RequiredError(
-                'participantId',
-                'Required parameter "participantId" was null or undefined when calling apiInvitesIdParticipantsParticipantIdCallMetadataGet().'
+                'fileId',
+                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdDelete().'
             );
         }
 
@@ -2131,43 +2064,42 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/participants/{participantId}/callMetadata`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"participantId"}}`, encodeURIComponent(String(requestParameters['participantId'])));
+        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: 'GET',
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get call metadata by invite ID and participant ID
+     * Remove a file from a project
      */
-    async apiInvitesIdParticipantsParticipantIdCallMetadataGet(requestParameters: ApiInvitesIdParticipantsParticipantIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInvitesIdParticipantsParticipantIdCallMetadataGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async apiProjectsProjectIdFilesFileIdDelete(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Update invite
+     * Update project file metadata
      */
-    async apiInvitesIdPutRaw(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Invite>> {
-        if (requestParameters['id'] == null) {
+    async apiProjectsProjectIdFilesFileIdPutRaw(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdPut().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
             );
         }
 
-        if (requestParameters['apiInvitesIdPutRequest'] == null) {
+        if (requestParameters['fileId'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesIdPutRequest',
-                'Required parameter "apiInvitesIdPutRequest" was null or undefined when calling apiInvitesIdPut().'
+                'fileId',
+                'Required parameter "fileId" was null or undefined when calling apiProjectsProjectIdFilesFileIdPut().'
             );
         }
 
@@ -2186,42 +2118,46 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        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: ApiInvitesIdPutRequestToJSON(requestParameters['apiInvitesIdPutRequest']),
+            body: ApiProjectsProjectIdFilesFileIdPutRequestToJSON(requestParameters['apiProjectsProjectIdFilesFileIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
     }
 
     /**
-     * Update invite
+     * Update project file metadata
      */
-    async apiInvitesIdPut(requestParameters: ApiInvitesIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Invite> {
-        const response = await this.apiInvitesIdPutRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdFilesFileIdPut(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
+        const response = await this.apiProjectsProjectIdFilesFileIdPutRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all invite responses for an invite using invite ID
-     * Get invite responses
+     * Get files for a project
      */
-    async apiInvitesIdResponsesGetRaw(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiInvitesIdResponsesGet200Response>> {
-        if (requestParameters['id'] == null) {
+    async apiProjectsProjectIdFilesGetRaw(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsProjectIdFilesGet200Response>> {
+        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 apiProjectsProjectIdFilesGet().'
             );
         }
 
         const queryParameters: any = {};
 
+        if (requestParameters['category'] != null) {
+            queryParameters['category'] = requestParameters['category'];
+        }
+
         if (requestParameters['page'] != null) {
             queryParameters['page'] = requestParameters['page'];
         }
@@ -2230,10 +2166,6 @@ export class DefaultApi extends runtime.BaseAPI {
             queryParameters['limit'] = requestParameters['limit'];
         }
 
-        if (requestParameters['statuses'] != null) {
-            queryParameters['statuses'] = requestParameters['statuses'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2245,8 +2177,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        let urlPath = `/api/projects/{projectId}/files`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -2255,27 +2187,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiInvitesIdResponsesGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsProjectIdFilesGet200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get all invite responses for an invite using invite ID
-     * Get invite responses
+     * Get files for a project
      */
-    async apiInvitesIdResponsesGet(requestParameters: ApiInvitesIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiInvitesIdResponsesGet200Response> {
-        const response = await this.apiInvitesIdResponsesGetRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdFilesGet(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsProjectIdFilesGet200Response> {
+        const response = await this.apiProjectsProjectIdFilesGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create an invite response using invite ID
-     * Create invite response
+     * Add an existing file to a project
      */
-    async apiInvitesIdResponsesPostRaw(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
-        if (requestParameters['id'] == null) {
+    async apiProjectsProjectIdFilesPostRaw(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesPost().'
+                '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().'
             );
         }
 
@@ -2294,49 +2231,45 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        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: ApiInvitesIdResponsesPostRequestToJSON(requestParameters['apiInvitesIdResponsesPostRequest']),
+            body: ApiProjectsProjectIdFilesPostRequestToJSON(requestParameters['apiProjectsProjectIdFilesPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
     }
 
     /**
-     * Create an invite response using invite ID
-     * Create invite response
+     * Add an existing file to a project
      */
-    async apiInvitesIdResponsesPost(requestParameters: ApiInvitesIdResponsesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesPostRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdFilesPost(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
+        const response = await this.apiProjectsProjectIdFilesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get call metadata by invite ID and response ID
+     * Get project
      */
-    async apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
-            );
-        }
-
-        if (requestParameters['responseId'] == null) {
+    async apiProjectsProjectIdGetRaw(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdCallMetadataGet().'
+                '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) {
@@ -2348,9 +2281,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/{id}/responses/{responseId}/callMetadata`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
-        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
+        let urlPath = `/api/projects/{projectId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -2359,33 +2291,25 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Get call metadata by invite ID and response ID
+     * Get project
      */
-    async apiInvitesIdResponsesResponseIdCallMetadataGet(requestParameters: ApiInvitesIdResponsesResponseIdCallMetadataGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
-        const response = await this.apiInvitesIdResponsesResponseIdCallMetadataGetRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdGet(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get an invite response using invite ID and response ID
-     * Get invite response
+     * Launch project
      */
-    async apiInvitesIdResponsesResponseIdGetRaw(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
-            );
-        }
-
-        if (requestParameters['responseId'] == null) {
+    async apiProjectsProjectIdLaunchPostRaw(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'responseId',
-                'Required parameter "responseId" was null or undefined when calling apiInvitesIdResponsesResponseIdGet().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdLaunchPost().'
             );
         }
 
@@ -2402,52 +2326,35 @@ 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/projects/{projectId}/launch`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
-            method: 'GET',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Get an invite response using invite ID and response ID
-     * Get invite response
+     * Launch project
      */
-    async apiInvitesIdResponsesResponseIdGet(requestParameters: ApiInvitesIdResponsesResponseIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesResponseIdGetRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdLaunchPost(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdLaunchPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update an invite response using invite ID and response ID
-     * Update invite response
+     * Update project
      */
-    async apiInvitesIdResponsesResponseIdPutRaw(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteResponse>> {
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError(
-                '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 apiInvitesIdResponsesResponseIdPut().'
-            );
-        }
-
-        if (requestParameters['apiInvitesIdResponsesResponseIdPutRequest'] == null) {
+    async apiProjectsProjectIdPutRaw(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesIdResponsesResponseIdPutRequest',
-                'Required parameter "apiInvitesIdResponsesResponseIdPutRequest" was null or undefined when calling apiInvitesIdResponsesResponseIdPut().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdPut().'
             );
         }
 
@@ -2466,38 +2373,36 @@ 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/projects/{projectId}`;
+        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
 
         const response = await this.request({
             path: urlPath,
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiInvitesIdResponsesResponseIdPutRequestToJSON(requestParameters['apiInvitesIdResponsesResponseIdPutRequest']),
+            body: ApiProjectsProjectIdPutRequestToJSON(requestParameters['apiProjectsProjectIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
     }
 
     /**
-     * Update an invite response using invite ID and response ID
-     * Update invite response
+     * Update project
      */
-    async apiInvitesIdResponsesResponseIdPut(requestParameters: ApiInvitesIdResponsesResponseIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteResponse> {
-        const response = await this.apiInvitesIdResponsesResponseIdPutRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdPut(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
+        const response = await this.apiProjectsProjectIdPutRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create invite
+     * Search project transcripts
      */
-    async apiInvitesPostRaw(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Invite>> {
-        if (requestParameters['apiInvitesPostRequest'] == null) {
+    async apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SearchProjectTranscriptsResponse>> {
+        if (requestParameters['projectId'] == null) {
             throw new runtime.RequiredError(
-                'apiInvitesPostRequest',
-                'Required parameter "apiInvitesPostRequest" was null or undefined when calling apiInvitesPost().'
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdSearchTranscriptsPost().'
             );
         }
 
@@ -2516,35 +2421,48 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/invites/`;
+        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: ApiInvitesPostRequestToJSON(requestParameters['apiInvitesPostRequest']),
+            body: ApiProjectsProjectIdSearchTranscriptsPostRequestToJSON(requestParameters['apiProjectsProjectIdSearchTranscriptsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => InviteFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => SearchProjectTranscriptsResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create invite
+     * Search project transcripts
      */
-    async apiInvitesPost(requestParameters: ApiInvitesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Invite> {
-        const response = await this.apiInvitesPostRaw(requestParameters, initOverrides);
+    async apiProjectsProjectIdSearchTranscriptsPost(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SearchProjectTranscriptsResponse> {
+        const response = await this.apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get draft project
+     * Get threads
      */
-    async apiProjectsDraftGetRaw(requestParameters: ApiProjectsDraftGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Project>> {
+    async apiThreadsGetRaw(requestParameters: ApiThreadsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsGet200Response>> {
         const queryParameters: any = {};
 
-        if (requestParameters['create'] != null) {
-            queryParameters['create'] = requestParameters['create'];
+        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 = {};
@@ -2558,7 +2476,7 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/draft`;
+        let urlPath = `/api/threads/`;
 
         const response = await this.request({
             path: urlPath,
@@ -2567,41 +2485,91 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsGet200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get draft project
+     * Get threads
      */
-    async apiProjectsDraftGet(requestParameters: ApiProjectsDraftGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Project> {
-        const response = await this.apiProjectsDraftGetRaw(requestParameters, initOverrides);
+    async apiThreadsGet(requestParameters: ApiThreadsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsGet200Response> {
+        const response = await this.apiThreadsGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get projects
+     * Get thread files
      */
-    async apiProjectsGetRaw(requestParameters: ApiProjectsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsGet200Response>> {
+    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['search'] != null) {
-            queryParameters['search'] = requestParameters['search'];
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
         }
 
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
+        if (requestParameters['fileNames'] != null) {
+            queryParameters['fileNames'] = requestParameters['fileNames'];
         }
 
-        if (requestParameters['statuses'] != null) {
-            queryParameters['statuses'] = requestParameters['statuses'];
+        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", []);
@@ -2611,7 +2579,54 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/`;
+        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 apiThreadsThreadIdPost(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Thread> {
+        const response = await this.apiThreadsThreadIdPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get project brief versions from thread state history
+     */
+    async apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
+        if (requestParameters['threadId'] == null) {
+            throw new runtime.RequiredError(
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsGet().'
+            );
+        }
+
+        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,
@@ -2620,25 +2635,25 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get projects
+     * Get project brief versions from thread state history
      */
-    async apiProjectsGet(requestParameters: ApiProjectsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsGet200Response> {
-        const response = await this.apiProjectsGetRaw(requestParameters, initOverrides);
+    async apiThreadsThreadIdProjectBriefVersionsGet(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
+        const response = await this.apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project
+     * Create project draft versions from thread state history
      */
-    async apiProjectsPostRaw(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['apiProjectsPostRequest'] == null) {
+    async apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
+        if (requestParameters['threadId'] == null) {
             throw new runtime.RequiredError(
-                'apiProjectsPostRequest',
-                'Required parameter "apiProjectsPostRequest" was null or undefined when calling apiProjectsPost().'
+                'threadId',
+                'Required parameter "threadId" was null or undefined when calling apiThreadsThreadIdProjectBriefVersionsPost().'
             );
         }
 
@@ -2657,38 +2672,76 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/`;
+        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: ApiProjectsPostRequestToJSON(requestParameters['apiProjectsPostRequest']),
+            body: ProjectBriefToJSON(requestParameters['projectBrief']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        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'])));
+
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
     }
 
     /**
-     * Create project
+     * Get user
      */
-    async apiProjectsPost(requestParameters: ApiProjectsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsPostRaw(requestParameters, initOverrides);
+    async apiUsersIdGet(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
+        const response = await this.apiUsersIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project analysis
      */
-    async apiProjectsProjectIdAnalysisPostRaw(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
-        if (requestParameters['projectId'] == null) {
-            throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdAnalysisPost().'
-            );
-        }
-
+    async apiVapiWebhookPostRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -2702,8 +2755,7 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/analysis`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/vapi/webhook`;
 
         const response = await this.request({
             path: urlPath,
@@ -2712,36 +2764,36 @@ export class DefaultApi extends runtime.BaseAPI {
             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.VoidApiResponse(response);
     }
 
     /**
-     * Create project analysis
      */
-    async apiProjectsProjectIdAnalysisPost(requestParameters: ApiProjectsProjectIdAnalysisPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
-        const response = await this.apiProjectsProjectIdAnalysisPostRaw(requestParameters, initOverrides);
-        return await response.value();
+    async apiVapiWebhookPost(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiVapiWebhookPostRaw(initOverrides);
     }
 
     /**
-     * Delete or archive project
+     * Create invite response for invite code
      */
-    async apiProjectsProjectIdDeletePostRaw(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async createCodeInviteResponseRaw(requestParameters: CreateCodeInviteResponseOperationRequest, 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 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", []);
@@ -2751,42 +2803,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`;
+        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) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Delete or archive project
+     * Create invite response for invite code
      */
-    async apiProjectsProjectIdDeletePost(requestParameters: ApiProjectsProjectIdDeletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdDeletePostRaw(requestParameters, initOverrides);
+    async createCodeInviteResponse(requestParameters: CreateCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Remove a file from a project
+     * Create invite response from existing response
      */
-    async apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['projectId'] == null) {
+    async createCodeInviteResponseFromExistingRaw(requestParameters: CreateCodeInviteResponseFromExistingRequest, 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 apiProjectsProjectIdFilesFileIdDelete().'
+                'code',
+                'Required parameter "code" was null or undefined when calling createCodeInviteResponseFromExisting().'
             );
         }
 
-        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 createCodeInviteResponseFromExisting().'
             );
         }
 
@@ -2803,50 +2856,53 @@ 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}/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: 'DELETE',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Remove a file from a project
+     * Create invite response from existing response
      */
-    async apiProjectsProjectIdFilesFileIdDelete(requestParameters: ApiProjectsProjectIdFilesFileIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiProjectsProjectIdFilesFileIdDeleteRaw(requestParameters, initOverrides);
+    async createCodeInviteResponseFromExisting(requestParameters: CreateCodeInviteResponseFromExistingRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createCodeInviteResponseFromExistingRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Update project file metadata
+     * Create test invite for participant
      */
-    async apiProjectsProjectIdFilesFileIdPutRaw(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
-        if (requestParameters['projectId'] == null) {
+    async createTestParticipantCodeInviteRaw(requestParameters: CreateTestParticipantCodeInviteRequest, 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 apiProjectsProjectIdFilesFileIdPut().'
+                'code',
+                'Required parameter "code" was null or undefined when calling createTestParticipantCodeInvite().'
             );
         }
 
-        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 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;
@@ -2857,53 +2913,47 @@ 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}/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: 'PUT',
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdFilesFileIdPutRequestToJSON(requestParameters['apiProjectsProjectIdFilesFileIdPutRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFileFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Update project file metadata
+     * Create test invite for participant
      */
-    async apiProjectsProjectIdFilesFileIdPut(requestParameters: ApiProjectsProjectIdFilesFileIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
-        const response = await this.apiProjectsProjectIdFilesFileIdPutRaw(requestParameters, initOverrides);
+    async createTestParticipantCodeInvite(requestParameters: CreateTestParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.createTestParticipantCodeInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get files for a project
+     * Create transcript insight for invite response
      */
-    async apiProjectsProjectIdFilesGetRaw(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiProjectsProjectIdFilesGet200Response>> {
-        if (requestParameters['projectId'] == null) {
+    async createTranscriptInsightForCodeInviteResponseRaw(requestParameters: CreateTranscriptInsightForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling createTranscriptInsightForCodeInviteResponse().'
             );
         }
 
-        const queryParameters: any = {};
-
-        if (requestParameters['category'] != null) {
-            queryParameters['category'] = requestParameters['category'];
-        }
-
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling createTranscriptInsightForCodeInviteResponse().'
+            );
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
+        const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -2916,42 +2966,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        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);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiProjectsProjectIdFilesGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Get files for a project
+     * Create transcript insight for invite response
      */
-    async apiProjectsProjectIdFilesGet(requestParameters: ApiProjectsProjectIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiProjectsProjectIdFilesGet200Response> {
-        const response = await this.apiProjectsProjectIdFilesGetRaw(requestParameters, initOverrides);
+    async createTranscriptInsightForCodeInviteResponse(requestParameters: CreateTranscriptInsightForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.createTranscriptInsightForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Add an existing file to a project
+     * Get call metadata for invite response
      */
-    async apiProjectsProjectIdFilesPostRaw(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectFile>> {
-        if (requestParameters['projectId'] == null) {
+    async getCallMetadataForCodeInviteResponseRaw(requestParameters: GetCallMetadataForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CallMetadata>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCallMetadataForCodeInviteResponse().'
             );
         }
 
-        if (requestParameters['apiProjectsProjectIdFilesPostRequest'] == null) {
+        if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
-                'apiProjectsProjectIdFilesPostRequest',
-                'Required parameter "apiProjectsProjectIdFilesPostRequest" was null or undefined when calling apiProjectsProjectIdFilesPost().'
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCallMetadataForCodeInviteResponse().'
             );
         }
 
@@ -2959,8 +3010,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", []);
@@ -2970,43 +3019,43 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/files`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        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,
-            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) => CallMetadataFromJSON(jsonValue));
     }
 
     /**
-     * Add an existing file to a project
+     * Get call metadata for invite response
      */
-    async apiProjectsProjectIdFilesPost(requestParameters: ApiProjectsProjectIdFilesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectFile> {
-        const response = await this.apiProjectsProjectIdFilesPostRaw(requestParameters, initOverrides);
+    async getCallMetadataForCodeInviteResponse(requestParameters: GetCallMetadataForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CallMetadata> {
+        const response = await this.getCallMetadataForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project
+     * Get invite by code
      */
-    async apiProjectsProjectIdGetRaw(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeInviteRaw(requestParameters: GetCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCodeInvite200Response>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInvite().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['includeThread'] != null) {
-            queryParameters['includeThread'] = requestParameters['includeThread'];
+        if (requestParameters['participantCode'] != null) {
+            queryParameters['participantCode'] = requestParameters['participantCode'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -3020,8 +3069,8 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        let urlPath = `/api/inviteCode/{code}/`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3030,30 +3079,41 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCodeInvite200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get project
+     * Get invite by code
      */
-    async apiProjectsProjectIdGet(requestParameters: ApiProjectsProjectIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdGetRaw(requestParameters, initOverrides);
+    async getCodeInvite(requestParameters: GetCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCodeInvite200Response> {
+        const response = await this.getCodeInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Launch project
+     * Get remaining responses count for participant
      */
-    async apiProjectsProjectIdLaunchPostRaw(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        if (requestParameters['projectId'] == null) {
+    async getCodeInviteParticipantRemainingResponsesRaw(requestParameters: GetCodeInviteParticipantRemainingResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RemainingResponsesResponse>> {
+        if (requestParameters['responseId'] == null) {
             throw new runtime.RequiredError(
-                'projectId',
-                'Required parameter "projectId" was null or undefined when calling apiProjectsProjectIdLaunchPost().'
+                '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 = {};
 
+        if (requestParameters['responseId'] != null) {
+            queryParameters['responseId'] = requestParameters['responseId'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -3065,43 +3125,52 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}/launch`;
-        urlPath = urlPath.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters['projectId'])));
+        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,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectWithAnalyticsFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => RemainingResponsesResponseFromJSON(jsonValue));
     }
 
     /**
-     * Launch project
+     * Get remaining responses count for participant
      */
-    async apiProjectsProjectIdLaunchPost(requestParameters: ApiProjectsProjectIdLaunchPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdLaunchPostRaw(requestParameters, initOverrides);
+    async getCodeInviteParticipantRemainingResponses(requestParameters: GetCodeInviteParticipantRemainingResponsesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RemainingResponsesResponse> {
+        const response = await this.getCodeInviteParticipantRemainingResponsesRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update project
+     * Get invite response for participant
      */
-    async apiProjectsProjectIdPutRaw(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectWithAnalytics>> {
-        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 apiProjectsProjectIdPut().'
+                '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 = {};
 
-        const headerParameters: runtime.HTTPHeaders = {};
+        if (requestParameters['participantCode'] != null) {
+            queryParameters['participantCode'] = requestParameters['participantCode'];
+        }
 
-        headerParameters['Content-Type'] = 'application/json';
+        const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
@@ -3112,48 +3181,46 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/projects/{projectId}`;
-        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: '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) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Update project
-     */
-    async apiProjectsProjectIdPut(requestParameters: ApiProjectsProjectIdPutOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectWithAnalytics> {
-        const response = await this.apiProjectsProjectIdPutRaw(requestParameters, initOverrides);
+     * Get invite response for participant
+     */
+    async getCodeInviteParticipantResponse(requestParameters: GetCodeInviteParticipantResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.getCodeInviteParticipantResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get project responses
+     * Get invite response
      */
-    async apiProjectsProjectIdResponsesGetRaw(requestParameters: ApiProjectsProjectIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetProjectResponsesResponse>> {
-        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 apiProjectsProjectIdResponsesGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteResponse().'
             );
         }
 
-        const queryParameters: any = {};
-
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCodeInviteResponse().'
+            );
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
+        const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -3166,8 +3233,9 @@ 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}/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,
@@ -3176,25 +3244,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => GetProjectResponsesResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get project responses
+     * Get invite response
      */
-    async apiProjectsProjectIdResponsesGet(requestParameters: ApiProjectsProjectIdResponsesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetProjectResponsesResponse> {
-        const response = await this.apiProjectsProjectIdResponsesGetRaw(requestParameters, initOverrides);
+    async getCodeInviteResponse(requestParameters: GetCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.getCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Search project transcripts
+     * Get redirect URL for invite response
      */
-    async apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SearchProjectTranscriptsResponse>> {
-        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 apiProjectsProjectIdSearchTranscriptsPost().'
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeInviteResponseRedirect().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling getCodeInviteResponseRedirect().'
             );
         }
 
@@ -3202,8 +3277,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", []);
@@ -3213,49 +3286,47 @@ 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}/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: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ApiProjectsProjectIdSearchTranscriptsPostRequestToJSON(requestParameters['apiProjectsProjectIdSearchTranscriptsPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SearchProjectTranscriptsResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCodeInviteResponseRedirect200ResponseFromJSON(jsonValue));
     }
 
     /**
-     * Search project transcripts
+     * Get redirect URL for invite response
      */
-    async apiProjectsProjectIdSearchTranscriptsPost(requestParameters: ApiProjectsProjectIdSearchTranscriptsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SearchProjectTranscriptsResponse> {
-        const response = await this.apiProjectsProjectIdSearchTranscriptsPostRaw(requestParameters, initOverrides);
+    async getCodeInviteResponseRedirect(requestParameters: GetCodeInviteResponseRedirectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCodeInviteResponseRedirect200Response> {
+        const response = await this.getCodeInviteResponseRedirectRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get threads
+     * Get participant invite for invite code
      */
-    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 getCodeParticipantInviteRaw(requestParameters: GetCodeParticipantInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ParticipantInvite>> {
+        if (requestParameters['code'] == null) {
+            throw new runtime.RequiredError(
+                'code',
+                'Required parameter "code" was null or undefined when calling getCodeParticipantInvite().'
+            );
         }
 
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
+        if (requestParameters['participantCode'] == null) {
+            throw new runtime.RequiredError(
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling getCodeParticipantInvite().'
+            );
         }
 
-        if (requestParameters['offset'] != null) {
-            queryParameters['offset'] = requestParameters['offset'];
-        }
+        const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
@@ -3268,7 +3339,9 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/`;
+        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,
@@ -3277,40 +3350,32 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ParticipantInviteFromJSON(jsonValue));
     }
 
     /**
-     * Get threads
+     * Get participant invite for invite code
      */
-    async apiThreadsGet(requestParameters: ApiThreadsGetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsGet200Response> {
-        const response = await this.apiThreadsGetRaw(requestParameters, initOverrides);
+    async getCodeParticipantInvite(requestParameters: GetCodeParticipantInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ParticipantInvite> {
+        const response = await this.getCodeParticipantInviteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get thread files
+     * Join invite by code
      */
-    async apiThreadsThreadIdFilesGetRaw(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdFilesGet200Response>> {
-        if (requestParameters['threadId'] == null) {
+    async joinCodeInviteRaw(requestParameters: JoinCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        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 joinCodeInvite().'
             );
         }
 
         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'];
+        if (requestParameters['rdud'] != null) {
+            queryParameters['rdud'] = requestParameters['rdud'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -3324,8 +3389,8 @@ 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}/join`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3334,25 +3399,31 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdFilesGet200ResponseFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get thread files
+     * Join invite by code
      */
-    async apiThreadsThreadIdFilesGet(requestParameters: ApiThreadsThreadIdFilesGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdFilesGet200Response> {
-        const response = await this.apiThreadsThreadIdFilesGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async joinCodeInvite(requestParameters: JoinCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.joinCodeInviteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Upsert thread
+     * Join invite by code and participant code
      */
-    async apiThreadsThreadIdPostRaw(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Thread>> {
-        if (requestParameters['threadId'] == null) {
+    async joinParticipantCodeInviteRaw(requestParameters: JoinParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        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 joinParticipantCodeInvite().'
+            );
+        }
+
+        if (requestParameters['participantCode'] == null) {
+            throw new runtime.RequiredError(
+                'participantCode',
+                'Required parameter "participantCode" was null or undefined when calling joinParticipantCodeInvite().'
             );
         }
 
@@ -3360,8 +3431,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", []);
@@ -3371,36 +3440,42 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/threads/{threadId}`;
-        urlPath = urlPath.replace(`{${"threadId"}}`, encodeURIComponent(String(requestParameters['threadId'])));
+        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: ApiThreadsThreadIdPostRequestToJSON(requestParameters['apiThreadsThreadIdPostRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ThreadFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Upsert thread
+     * Join invite by code and participant code
      */
-    async apiThreadsThreadIdPost(requestParameters: ApiThreadsThreadIdPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Thread> {
-        const response = await this.apiThreadsThreadIdPostRaw(requestParameters, initOverrides);
-        return await response.value();
+    async joinParticipantCodeInvite(requestParameters: JoinParticipantCodeInviteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.joinParticipantCodeInviteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get project brief versions from thread state history
+     * Start call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
-        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 apiThreadsThreadIdProjectBriefVersionsGet().'
+                'code',
+                'Required parameter "code" was null or undefined when calling startCallForCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling startCallForCodeInviteResponse().'
             );
         }
 
@@ -3417,8 +3492,9 @@ 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}/startCall`;
+        urlPath = urlPath.replace(`{${"code"}}`, encodeURIComponent(String(requestParameters['code'])));
+        urlPath = urlPath.replace(`{${"responseId"}}`, encodeURIComponent(String(requestParameters['responseId'])));
 
         const response = await this.request({
             path: urlPath,
@@ -3427,25 +3503,39 @@ export class DefaultApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => InboundCallResponseFromJSON(jsonValue));
     }
 
     /**
-     * Get project brief versions from thread state history
+     * Start call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsGet(requestParameters: ApiThreadsThreadIdProjectBriefVersionsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
-        const response = await this.apiThreadsThreadIdProjectBriefVersionsGetRaw(requestParameters, initOverrides);
+    async startCallForCodeInviteResponse(requestParameters: StartCallForCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InboundCallResponse> {
+        const response = await this.startCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create project draft versions from thread state history
+     * Start phone call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiThreadsThreadIdProjectBriefVersionsGet200Response>> {
-        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 apiThreadsThreadIdProjectBriefVersionsPost().'
+                '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().'
             );
         }
 
@@ -3464,36 +3554,51 @@ 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}/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: ProjectBriefToJSON(requestParameters['projectBrief']),
+            body: StartPhoneCallForCodeInviteResponseRequestToJSON(requestParameters['startPhoneCallForCodeInviteResponseRequest']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ApiThreadsThreadIdProjectBriefVersionsGet200ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PhoneCallStartResponseFromJSON(jsonValue));
     }
 
     /**
-     * Create project draft versions from thread state history
+     * Start phone call for invite response
      */
-    async apiThreadsThreadIdProjectBriefVersionsPost(requestParameters: ApiThreadsThreadIdProjectBriefVersionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiThreadsThreadIdProjectBriefVersionsGet200Response> {
-        const response = await this.apiThreadsThreadIdProjectBriefVersionsPostRaw(requestParameters, initOverrides);
+    async startPhoneCallForCodeInviteResponse(requestParameters: StartPhoneCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PhoneCallStartResponse> {
+        const response = await this.startPhoneCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get user
+     * Update call for invite response
      */
-    async apiUsersIdGetRaw(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters['id'] == null) {
+    async updateCallForCodeInviteResponseRaw(requestParameters: UpdateCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
+        if (requestParameters['code'] == null) {
             throw new runtime.RequiredError(
-                'id',
-                'Required parameter "id" was null or undefined when calling apiUsersIdGet().'
+                '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().'
             );
         }
 
@@ -3501,6 +3606,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", []);
@@ -3510,34 +3617,57 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/users/{id}`;
-        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        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) => UserFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<any>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Get user
+     * Update call for invite response
      */
-    async apiUsersIdGet(requestParameters: ApiUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
-        const response = await this.apiUsersIdGetRaw(requestParameters, initOverrides);
+    async updateCallForCodeInviteResponse(requestParameters: UpdateCallForCodeInviteResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
+        const response = await this.updateCallForCodeInviteResponseRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * Update invite response
      */
-    async apiVapiWebhookPostRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async updateCodeInviteResponseRaw(requestParameters: UpdateCodeInviteResponseRequest, 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 updateCodeInviteResponse().'
+            );
+        }
+
+        if (requestParameters['responseId'] == null) {
+            throw new runtime.RequiredError(
+                'responseId',
+                'Required parameter "responseId" was null or undefined when calling updateCodeInviteResponse().'
+            );
+        }
+
         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", []);
@@ -3547,22 +3677,27 @@ export class DefaultApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/api/vapi/webhook`;
+        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: InviteResponseUpdateEventToJSON(requestParameters['inviteResponseUpdateEvent']),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CodeInviteResponseFromJSON(jsonValue));
     }
 
     /**
+     * Update invite response
      */
-    async apiVapiWebhookPost(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.apiVapiWebhookPostRaw(initOverrides);
+    async updateCodeInviteResponse(requestParameters: UpdateCodeInviteResponseRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CodeInviteResponse> {
+        const response = await this.updateCodeInviteResponseRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }