@stream-io/node-sdk 0.4.26 → 0.5.1

package/src/gen/video/VideoApi.ts

@@ -1,5 +1,4 @@
-import { BaseApi } from '../../BaseApi';
-import { StreamResponse } from '../../types';
+import { ApiClient, StreamResponse } from '../../gen-imports';
 import {
   BlockUserRequest,
   BlockUserResponse,
@@ -79,24 +78,26 @@ import {
   UpdateUserPermissionsRequest,
   UpdateUserPermissionsResponse,
 } from '../models';
-import { decoders } from '../model-decoders';
+import { decoders } from '../model-decoders/decoders';
 
-export class VideoApi extends BaseApi {
-  getActiveCallsStatus = async (): Promise<
+export class VideoApi {
+  constructor(public readonly apiClient: ApiClient) {}
+
+  async getActiveCallsStatus(): Promise<
     StreamResponse<GetActiveCallsStatusResponse>
-  > => {
-    const response = await this.sendRequest<
+  > {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetActiveCallsStatusResponse>
     >('GET', '/api/v2/video/active_calls_status', undefined, undefined);
 
     decoders.GetActiveCallsStatusResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryUserFeedback = async (
+  async queryUserFeedback(
     request?: QueryUserFeedbackRequest & { full?: boolean },
-  ): Promise<StreamResponse<QueryUserFeedbackResponse>> => {
+  ): Promise<StreamResponse<QueryUserFeedbackResponse>> {
     const queryParams = {
       full: request?.full,
     };
@@ -108,18 +109,25 @@ export class VideoApi extends BaseApi {
       filter_conditions: request?.filter_conditions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryUserFeedbackResponse>
-    >('POST', '/api/v2/video/call/feedback', undefined, queryParams, body);
+    >(
+      'POST',
+      '/api/v2/video/call/feedback',
+      undefined,
+      queryParams,
+      body,
+      'application/json',
+    );
 
     decoders.QueryUserFeedbackResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryCallMembers = async (
+  async queryCallMembers(
     request: QueryCallMembersRequest,
-  ): Promise<StreamResponse<QueryCallMembersResponse>> => {
+  ): Promise<StreamResponse<QueryCallMembersResponse>> {
     const body = {
       id: request?.id,
       type: request?.type,
@@ -130,18 +138,25 @@ export class VideoApi extends BaseApi {
       filter_conditions: request?.filter_conditions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryCallMembersResponse>
-    >('POST', '/api/v2/video/call/members', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/video/call/members',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryCallMembersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryCallStats = async (
+  async queryCallStats(
     request?: QueryCallStatsRequest,
-  ): Promise<StreamResponse<QueryCallStatsResponse>> => {
+  ): Promise<StreamResponse<QueryCallStatsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -150,23 +165,30 @@ export class VideoApi extends BaseApi {
       filter_conditions: request?.filter_conditions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryCallStatsResponse>
-    >('POST', '/api/v2/video/call/stats', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/video/call/stats',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryCallStatsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getCall = async (request: {
+  async getCall(request: {
     type: string;
     id: string;
     members_limit?: number;
     ring?: boolean;
     notify?: boolean;
     video?: boolean;
-  }): Promise<StreamResponse<GetCallResponse>> => {
+  }): Promise<StreamResponse<GetCallResponse>> {
     const queryParams = {
       members_limit: request?.members_limit,
       ring: request?.ring,
@@ -178,21 +200,18 @@ export class VideoApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetCallResponse>>(
-      'GET',
-      '/api/v2/video/call/{type}/{id}',
-      pathParams,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetCallResponse>
+    >('GET', '/api/v2/video/call/{type}/{id}', pathParams, queryParams);
 
     decoders.GetCallResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateCall = async (
+  async updateCall(
     request: UpdateCallRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UpdateCallResponse>> => {
+  ): Promise<StreamResponse<UpdateCallResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -203,22 +222,25 @@ export class VideoApi extends BaseApi {
       settings_override: request?.settings_override,
     };
 
-    const response = await this.sendRequest<StreamResponse<UpdateCallResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateCallResponse>
+    >(
       'PATCH',
       '/api/v2/video/call/{type}/{id}',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateCallResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getOrCreateCall = async (
+  async getOrCreateCall(
     request: GetOrCreateCallRequest & { type: string; id: string },
-  ): Promise<StreamResponse<GetOrCreateCallResponse>> => {
+  ): Promise<StreamResponse<GetOrCreateCallResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -231,18 +253,25 @@ export class VideoApi extends BaseApi {
       data: request?.data,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetOrCreateCallResponse>
-    >('POST', '/api/v2/video/call/{type}/{id}', pathParams, undefined, body);
+    >(
+      'POST',
+      '/api/v2/video/call/{type}/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.GetOrCreateCallResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  blockUser = async (
+  async blockUser(
     request: BlockUserRequest & { type: string; id: string },
-  ): Promise<StreamResponse<BlockUserResponse>> => {
+  ): Promise<StreamResponse<BlockUserResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -251,22 +280,25 @@ export class VideoApi extends BaseApi {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<BlockUserResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<BlockUserResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/block',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.BlockUserResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteCall = async (
+  async deleteCall(
     request: DeleteCallRequest & { type: string; id: string },
-  ): Promise<StreamResponse<DeleteCallResponse>> => {
+  ): Promise<StreamResponse<DeleteCallResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -275,22 +307,25 @@ export class VideoApi extends BaseApi {
       hard: request?.hard,
     };
 
-    const response = await this.sendRequest<StreamResponse<DeleteCallResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteCallResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/delete',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.DeleteCallResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  sendCallEvent = async (
+  async sendCallEvent(
     request: SendCallEventRequest & { type: string; id: string },
-  ): Promise<StreamResponse<SendCallEventResponse>> => {
+  ): Promise<StreamResponse<SendCallEventResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -301,7 +336,7 @@ export class VideoApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SendCallEventResponse>
     >(
       'POST',
@@ -309,16 +344,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.SendCallEventResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  collectUserFeedback = async (
+  async collectUserFeedback(
     request: CollectUserFeedbackRequest & { type: string; id: string },
-  ): Promise<StreamResponse<CollectUserFeedbackResponse>> => {
+  ): Promise<StreamResponse<CollectUserFeedbackResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -332,7 +368,7 @@ export class VideoApi extends BaseApi {
       custom: request?.custom,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CollectUserFeedbackResponse>
     >(
       'POST',
@@ -340,16 +376,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CollectUserFeedbackResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  goLive = async (
+  async goLive(
     request: GoLiveRequest & { type: string; id: string },
-  ): Promise<StreamResponse<GoLiveResponse>> => {
+  ): Promise<StreamResponse<GoLiveResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -363,29 +400,34 @@ export class VideoApi extends BaseApi {
       transcription_storage_name: request?.transcription_storage_name,
     };
 
-    const response = await this.sendRequest<StreamResponse<GoLiveResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GoLiveResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/go_live',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.GoLiveResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  endCall = async (request: {
+  async endCall(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<EndCallResponse>> => {
+  }): Promise<StreamResponse<EndCallResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<EndCallResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<EndCallResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/mark_ended',
       pathParams,
@@ -395,11 +437,11 @@ export class VideoApi extends BaseApi {
     decoders.EndCallResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateCallMembers = async (
+  async updateCallMembers(
     request: UpdateCallMembersRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UpdateCallMembersResponse>> => {
+  ): Promise<StreamResponse<UpdateCallMembersResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -409,7 +451,7 @@ export class VideoApi extends BaseApi {
       update_members: request?.update_members,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateCallMembersResponse>
     >(
       'POST',
@@ -417,16 +459,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateCallMembersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  muteUsers = async (
+  async muteUsers(
     request: MuteUsersRequest & { type: string; id: string },
-  ): Promise<StreamResponse<MuteUsersResponse>> => {
+  ): Promise<StreamResponse<MuteUsersResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -442,26 +485,29 @@ export class VideoApi extends BaseApi {
       muted_by: request?.muted_by,
     };
 
-    const response = await this.sendRequest<StreamResponse<MuteUsersResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MuteUsersResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/mute_users',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MuteUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryCallParticipants = async (
+  async queryCallParticipants(
     request: QueryCallParticipantsRequest & {
       id: string;
       type: string;
       limit?: number;
     },
-  ): Promise<StreamResponse<QueryCallParticipantsResponse>> => {
+  ): Promise<StreamResponse<QueryCallParticipantsResponse>> {
     const queryParams = {
       limit: request?.limit,
     };
@@ -473,7 +519,7 @@ export class VideoApi extends BaseApi {
       filter_conditions: request?.filter_conditions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryCallParticipantsResponse>
     >(
       'POST',
@@ -481,16 +527,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       queryParams,
       body,
+      'application/json',
     );
 
     decoders.QueryCallParticipantsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  videoPin = async (
+  async videoPin(
     request: PinRequest & { type: string; id: string },
-  ): Promise<StreamResponse<PinResponse>> => {
+  ): Promise<StreamResponse<PinResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -500,29 +547,32 @@ export class VideoApi extends BaseApi {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<PinResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PinResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/pin',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.PinResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listRecordings = async (request: {
+  async listRecordings(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<ListRecordingsResponse>> => {
+  }): Promise<StreamResponse<ListRecordingsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListRecordingsResponse>
     >(
       'GET',
@@ -534,13 +584,13 @@ export class VideoApi extends BaseApi {
     decoders.ListRecordingsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getCallReport = async (request: {
+  async getCallReport(request: {
     type: string;
     id: string;
     session_id?: string;
-  }): Promise<StreamResponse<GetCallReportResponse>> => {
+  }): Promise<StreamResponse<GetCallReportResponse>> {
     const queryParams = {
       session_id: request?.session_id,
     };
@@ -549,18 +599,18 @@ export class VideoApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetCallReportResponse>
     >('GET', '/api/v2/video/call/{type}/{id}/report', pathParams, queryParams);
 
     decoders.GetCallReportResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startRTMPBroadcasts = async (
+  async startRTMPBroadcasts(
     request: StartRTMPBroadcastsRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StartRTMPBroadcastsResponse>> => {
+  ): Promise<StreamResponse<StartRTMPBroadcastsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -569,7 +619,7 @@ export class VideoApi extends BaseApi {
       broadcasts: request?.broadcasts,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartRTMPBroadcastsResponse>
     >(
       'POST',
@@ -577,23 +627,24 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StartRTMPBroadcastsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopAllRTMPBroadcasts = async (request: {
+  async stopAllRTMPBroadcasts(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<StopAllRTMPBroadcastsResponse>> => {
+  }): Promise<StreamResponse<StopAllRTMPBroadcastsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopAllRTMPBroadcastsResponse>
     >(
       'POST',
@@ -605,15 +656,15 @@ export class VideoApi extends BaseApi {
     decoders.StopAllRTMPBroadcastsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopRTMPBroadcast = async (
+  async stopRTMPBroadcast(
     request: StopRTMPBroadcastsRequest & {
       type: string;
       id: string;
       name: string;
     },
-  ): Promise<StreamResponse<StopRTMPBroadcastsResponse>> => {
+  ): Promise<StreamResponse<StopRTMPBroadcastsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -621,7 +672,7 @@ export class VideoApi extends BaseApi {
     };
     const body = {};
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopRTMPBroadcastsResponse>
     >(
       'POST',
@@ -629,23 +680,24 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StopRTMPBroadcastsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startHLSBroadcasting = async (request: {
+  async startHLSBroadcasting(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<StartHLSBroadcastingResponse>> => {
+  }): Promise<StreamResponse<StartHLSBroadcastingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartHLSBroadcastingResponse>
     >(
       'POST',
@@ -657,11 +709,11 @@ export class VideoApi extends BaseApi {
     decoders.StartHLSBroadcastingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startClosedCaptions = async (
+  async startClosedCaptions(
     request: StartClosedCaptionsRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StartClosedCaptionsResponse>> => {
+  ): Promise<StreamResponse<StartClosedCaptionsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -672,7 +724,7 @@ export class VideoApi extends BaseApi {
       language: request?.language,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartClosedCaptionsResponse>
     >(
       'POST',
@@ -680,16 +732,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StartClosedCaptionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startFrameRecording = async (
+  async startFrameRecording(
     request: StartFrameRecordingRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StartFrameRecordingResponse>> => {
+  ): Promise<StreamResponse<StartFrameRecordingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -698,7 +751,7 @@ export class VideoApi extends BaseApi {
       recording_external_storage: request?.recording_external_storage,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartFrameRecordingResponse>
     >(
       'POST',
@@ -706,16 +759,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StartFrameRecordingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startRecording = async (
+  async startRecording(
     request: StartRecordingRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StartRecordingResponse>> => {
+  ): Promise<StreamResponse<StartRecordingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -724,7 +778,7 @@ export class VideoApi extends BaseApi {
       recording_external_storage: request?.recording_external_storage,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartRecordingResponse>
     >(
       'POST',
@@ -732,16 +786,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StartRecordingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startTranscription = async (
+  async startTranscription(
     request: StartTranscriptionRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StartTranscriptionResponse>> => {
+  ): Promise<StreamResponse<StartTranscriptionResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -752,7 +807,7 @@ export class VideoApi extends BaseApi {
       transcription_external_storage: request?.transcription_external_storage,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartTranscriptionResponse>
     >(
       'POST',
@@ -760,23 +815,24 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StartTranscriptionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopHLSBroadcasting = async (request: {
+  async stopHLSBroadcasting(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<StopHLSBroadcastingResponse>> => {
+  }): Promise<StreamResponse<StopHLSBroadcastingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopHLSBroadcastingResponse>
     >(
       'POST',
@@ -788,11 +844,11 @@ export class VideoApi extends BaseApi {
     decoders.StopHLSBroadcastingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopClosedCaptions = async (
+  async stopClosedCaptions(
     request: StopClosedCaptionsRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StopClosedCaptionsResponse>> => {
+  ): Promise<StreamResponse<StopClosedCaptionsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -801,7 +857,7 @@ export class VideoApi extends BaseApi {
       stop_transcription: request?.stop_transcription,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopClosedCaptionsResponse>
     >(
       'POST',
@@ -809,23 +865,24 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StopClosedCaptionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopFrameRecording = async (request: {
+  async stopFrameRecording(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<StopFrameRecordingResponse>> => {
+  }): Promise<StreamResponse<StopFrameRecordingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopFrameRecordingResponse>
     >(
       'POST',
@@ -837,11 +894,11 @@ export class VideoApi extends BaseApi {
     decoders.StopFrameRecordingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopLive = async (
+  async stopLive(
     request: StopLiveRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StopLiveResponse>> => {
+  ): Promise<StreamResponse<StopLiveResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -854,29 +911,32 @@ export class VideoApi extends BaseApi {
       continue_transcription: request?.continue_transcription,
     };
 
-    const response = await this.sendRequest<StreamResponse<StopLiveResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<StopLiveResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/stop_live',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StopLiveResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopRecording = async (request: {
+  async stopRecording(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<StopRecordingResponse>> => {
+  }): Promise<StreamResponse<StopRecordingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopRecordingResponse>
     >(
       'POST',
@@ -888,11 +948,11 @@ export class VideoApi extends BaseApi {
     decoders.StopRecordingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  stopTranscription = async (
+  async stopTranscription(
     request: StopTranscriptionRequest & { type: string; id: string },
-  ): Promise<StreamResponse<StopTranscriptionResponse>> => {
+  ): Promise<StreamResponse<StopTranscriptionResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -901,7 +961,7 @@ export class VideoApi extends BaseApi {
       stop_closed_captions: request?.stop_closed_captions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StopTranscriptionResponse>
     >(
       'POST',
@@ -909,23 +969,24 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.StopTranscriptionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listTranscriptions = async (request: {
+  async listTranscriptions(request: {
     type: string;
     id: string;
-  }): Promise<StreamResponse<ListTranscriptionsResponse>> => {
+  }): Promise<StreamResponse<ListTranscriptionsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListTranscriptionsResponse>
     >(
       'GET',
@@ -937,11 +998,11 @@ export class VideoApi extends BaseApi {
     decoders.ListTranscriptionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unblockUser = async (
+  async unblockUser(
     request: UnblockUserRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UnblockUserResponse>> => {
+  ): Promise<StreamResponse<UnblockUserResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -950,7 +1011,7 @@ export class VideoApi extends BaseApi {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UnblockUserResponse>
     >(
       'POST',
@@ -958,16 +1019,17 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UnblockUserResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  videoUnpin = async (
+  async videoUnpin(
     request: UnpinRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UnpinResponse>> => {
+  ): Promise<StreamResponse<UnpinResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -977,22 +1039,25 @@ export class VideoApi extends BaseApi {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<UnpinResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnpinResponse>
+    >(
       'POST',
       '/api/v2/video/call/{type}/{id}/unpin',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UnpinResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateUserPermissions = async (
+  async updateUserPermissions(
     request: UpdateUserPermissionsRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UpdateUserPermissionsResponse>> => {
+  ): Promise<StreamResponse<UpdateUserPermissionsResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -1003,7 +1068,7 @@ export class VideoApi extends BaseApi {
       revoke_permissions: request?.revoke_permissions,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateUserPermissionsResponse>
     >(
       'POST',
@@ -1011,19 +1076,20 @@ export class VideoApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateUserPermissionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteRecording = async (request: {
+  async deleteRecording(request: {
     type: string;
     id: string;
     session: string;
     filename: string;
-  }): Promise<StreamResponse<DeleteRecordingResponse>> => {
+  }): Promise<StreamResponse<DeleteRecordingResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -1031,7 +1097,7 @@ export class VideoApi extends BaseApi {
       filename: request?.filename,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteRecordingResponse>
     >(
       'DELETE',
@@ -1043,14 +1109,14 @@ export class VideoApi extends BaseApi {
     decoders.DeleteRecordingResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteTranscription = async (request: {
+  async deleteTranscription(request: {
     type: string;
     id: string;
     session: string;
     filename: string;
-  }): Promise<StreamResponse<DeleteTranscriptionResponse>> => {
+  }): Promise<StreamResponse<DeleteTranscriptionResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -1058,7 +1124,7 @@ export class VideoApi extends BaseApi {
       filename: request?.filename,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteTranscriptionResponse>
     >(
       'DELETE',
@@ -1070,11 +1136,11 @@ export class VideoApi extends BaseApi {
     decoders.DeleteTranscriptionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryCalls = async (
+  async queryCalls(
     request?: QueryCallsRequest,
-  ): Promise<StreamResponse<QueryCallsResponse>> => {
+  ): Promise<StreamResponse<QueryCallsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -1083,32 +1149,35 @@ export class VideoApi extends BaseApi {
       filter_conditions: request?.filter_conditions,
     };
 
-    const response = await this.sendRequest<StreamResponse<QueryCallsResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryCallsResponse>
+    >(
       'POST',
       '/api/v2/video/calls',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.QueryCallsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listCallTypes = async (): Promise<StreamResponse<ListCallTypeResponse>> => {
-    const response = await this.sendRequest<
+  async listCallTypes(): Promise<StreamResponse<ListCallTypeResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListCallTypeResponse>
     >('GET', '/api/v2/video/calltypes', undefined, undefined);
 
     decoders.ListCallTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createCallType = async (
+  async createCallType(
     request: CreateCallTypeRequest,
-  ): Promise<StreamResponse<CreateCallTypeResponse>> => {
+  ): Promise<StreamResponse<CreateCallTypeResponse>> {
     const body = {
       name: request?.name,
       external_storage: request?.external_storage,
@@ -1117,23 +1186,30 @@ export class VideoApi extends BaseApi {
       settings: request?.settings,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateCallTypeResponse>
-    >('POST', '/api/v2/video/calltypes', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/video/calltypes',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateCallTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteCallType = async (request: {
+  async deleteCallType(request: {
     name: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/video/calltypes/{name}',
       pathParams,
@@ -1143,27 +1219,27 @@ export class VideoApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getCallType = async (request: {
+  async getCallType(request: {
     name: string;
-  }): Promise<StreamResponse<GetCallTypeResponse>> => {
+  }): Promise<StreamResponse<GetCallTypeResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetCallTypeResponse>
     >('GET', '/api/v2/video/calltypes/{name}', pathParams, undefined);
 
     decoders.GetCallTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateCallType = async (
+  async updateCallType(
     request: UpdateCallTypeRequest & { name: string },
-  ): Promise<StreamResponse<UpdateCallTypeResponse>> => {
+  ): Promise<StreamResponse<UpdateCallTypeResponse>> {
     const pathParams = {
       name: request?.name,
     };
@@ -1174,43 +1250,54 @@ export class VideoApi extends BaseApi {
       settings: request?.settings,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateCallTypeResponse>
-    >('PUT', '/api/v2/video/calltypes/{name}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/video/calltypes/{name}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateCallTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getEdges = async (): Promise<StreamResponse<GetEdgesResponse>> => {
-    const response = await this.sendRequest<StreamResponse<GetEdgesResponse>>(
-      'GET',
-      '/api/v2/video/edges',
-      undefined,
-      undefined,
-    );
+  async getEdges(): Promise<StreamResponse<GetEdgesResponse>> {
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetEdgesResponse>
+    >('GET', '/api/v2/video/edges', undefined, undefined);
 
     decoders.GetEdgesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryAggregateCallStats = async (
+  async queryAggregateCallStats(
     request?: QueryAggregateCallStatsRequest,
-  ): Promise<StreamResponse<QueryAggregateCallStatsResponse>> => {
+  ): Promise<StreamResponse<QueryAggregateCallStatsResponse>> {
     const body = {
       from: request?.from,
       to: request?.to,
       report_types: request?.report_types,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryAggregateCallStatsResponse>
-    >('POST', '/api/v2/video/stats', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/video/stats',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryAggregateCallStatsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 }