@stream-io/node-sdk 0.4.25 → 0.5.0

package/src/gen/chat/ChatApi.ts

@@ -1,5 +1,4 @@
-import { BaseApi } from '../../BaseApi';
-import { StreamResponse } from '../../types';
+import { ApiClient, StreamResponse } from '../../gen-imports';
 import {
   CampaignResponse,
   CastPollVoteRequest,
@@ -10,8 +9,6 @@ import {
   CreateChannelTypeResponse,
   CreateCommandRequest,
   CreateCommandResponse,
-  CreatePollOptionRequest,
-  CreatePollRequest,
   CreateReminderRequest,
   DeleteChannelResponse,
   DeleteChannelsRequest,
@@ -52,10 +49,7 @@ import {
   MessageResponse,
   MuteChannelRequest,
   MuteChannelResponse,
-  PollOptionResponse,
-  PollResponse,
   PollVoteResponse,
-  PollVotesResponse,
   QueryBannedUsersPayload,
   QueryBannedUsersResponse,
   QueryCampaignsRequest,
@@ -69,9 +63,6 @@ import {
   QueryMessageFlagsResponse,
   QueryMessageHistoryRequest,
   QueryMessageHistoryResponse,
-  QueryPollVotesRequest,
-  QueryPollsRequest,
-  QueryPollsResponse,
   QueryReactionsRequest,
   QueryReactionsResponse,
   QueryRemindersRequest,
@@ -119,9 +110,6 @@ import {
   UpdateMessagePartialResponse,
   UpdateMessageRequest,
   UpdateMessageResponse,
-  UpdatePollOptionRequest,
-  UpdatePollPartialRequest,
-  UpdatePollRequest,
   UpdateReminderRequest,
   UpdateReminderResponse,
   UpdateThreadPartialRequest,
@@ -132,12 +120,14 @@ import {
   UpsertPushTemplateResponse,
   WrappedUnreadCountsResponse,
 } from '../models';
-import { decoders } from '../model-decoders';
+import { decoders } from '../model-decoders/decoders';
 
-export class ChatApi extends BaseApi {
-  queryCampaigns = async (
+export class ChatApi {
+  constructor(public readonly apiClient: ApiClient) {}
+
+  async queryCampaigns(
     request?: QueryCampaignsRequest,
-  ): Promise<StreamResponse<QueryCampaignsResponse>> => {
+  ): Promise<StreamResponse<QueryCampaignsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -147,21 +137,28 @@ export class ChatApi extends BaseApi {
       filter: request?.filter,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryCampaignsResponse>
-    >('POST', '/api/v2/chat/campaigns/query', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/campaigns/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryCampaignsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getCampaign = async (request: {
+  async getCampaign(request: {
     id: string;
     prev?: string;
     next?: string;
     limit?: number;
-  }): Promise<StreamResponse<GetCampaignResponse>> => {
+  }): Promise<StreamResponse<GetCampaignResponse>> {
     const queryParams = {
       prev: request?.prev,
       next: request?.next,
@@ -171,18 +168,18 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetCampaignResponse>
     >('GET', '/api/v2/chat/campaigns/{id}', pathParams, queryParams);
 
     decoders.GetCampaignResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  startCampaign = async (
+  async startCampaign(
     request: StartCampaignRequest & { id: string },
-  ): Promise<StreamResponse<StartCampaignResponse>> => {
+  ): Promise<StreamResponse<StartCampaignResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -191,39 +188,49 @@ export class ChatApi extends BaseApi {
       stop_at: request?.stop_at,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<StartCampaignResponse>
-    >('POST', '/api/v2/chat/campaigns/{id}/start', pathParams, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/campaigns/{id}/start',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.StartCampaignResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  scheduleCampaign = async (
+  async scheduleCampaign(
     request: StopCampaignRequest & { id: string },
-  ): Promise<StreamResponse<CampaignResponse>> => {
+  ): Promise<StreamResponse<CampaignResponse>> {
     const pathParams = {
       id: request?.id,
     };
     const body = {};
 
-    const response = await this.sendRequest<StreamResponse<CampaignResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CampaignResponse>
+    >(
       'POST',
       '/api/v2/chat/campaigns/{id}/stop',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CampaignResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryChannels = async (
+  async queryChannels(
     request?: QueryChannelsRequest,
-  ): Promise<StreamResponse<QueryChannelsResponse>> => {
+  ): Promise<StreamResponse<QueryChannelsResponse>> {
     const body = {
       limit: request?.limit,
       member_limit: request?.member_limit,
@@ -236,57 +243,74 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryChannelsResponse>
-    >('POST', '/api/v2/chat/channels', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/channels',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryChannelsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteChannels = async (
+  async deleteChannels(
     request: DeleteChannelsRequest,
-  ): Promise<StreamResponse<DeleteChannelsResponse>> => {
+  ): Promise<StreamResponse<DeleteChannelsResponse>> {
     const body = {
       cids: request?.cids,
       hard_delete: request?.hard_delete,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteChannelsResponse>
-    >('POST', '/api/v2/chat/channels/delete', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/channels/delete',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.DeleteChannelsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  markChannelsRead = async (
+  async markChannelsRead(
     request?: MarkChannelsReadRequest,
-  ): Promise<StreamResponse<MarkReadResponse>> => {
+  ): Promise<StreamResponse<MarkReadResponse>> {
     const body = {
       user_id: request?.user_id,
       read_by_channel: request?.read_by_channel,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<MarkReadResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MarkReadResponse>
+    >(
       'POST',
       '/api/v2/chat/channels/read',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MarkReadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getOrCreateDistinctChannel = async (
+  async getOrCreateDistinctChannel(
     request: ChannelGetOrCreateRequest & { type: string },
-  ): Promise<StreamResponse<ChannelStateResponse>> => {
+  ): Promise<StreamResponse<ChannelStateResponse>> {
     const pathParams = {
       type: request?.type,
     };
@@ -300,7 +324,7 @@ export class ChatApi extends BaseApi {
       watchers: request?.watchers,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ChannelStateResponse>
     >(
       'POST',
@@ -308,18 +332,19 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.ChannelStateResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteChannel = async (request: {
+  async deleteChannel(request: {
     type: string;
     id: string;
     hard_delete?: boolean;
-  }): Promise<StreamResponse<DeleteChannelResponse>> => {
+  }): Promise<StreamResponse<DeleteChannelResponse>> {
     const queryParams = {
       hard_delete: request?.hard_delete,
     };
@@ -328,18 +353,18 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteChannelResponse>
     >('DELETE', '/api/v2/chat/channels/{type}/{id}', pathParams, queryParams);
 
     decoders.DeleteChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateChannelPartial = async (
+  async updateChannelPartial(
     request: UpdateChannelPartialRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UpdateChannelPartialResponse>> => {
+  ): Promise<StreamResponse<UpdateChannelPartialResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -351,7 +376,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateChannelPartialResponse>
     >(
       'PATCH',
@@ -359,16 +384,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateChannelPartialResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateChannel = async (
+  async updateChannel(
     request: UpdateChannelRequest & { type: string; id: string },
-  ): Promise<StreamResponse<UpdateChannelResponse>> => {
+  ): Promise<StreamResponse<UpdateChannelResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -391,21 +417,28 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateChannelResponse>
-    >('POST', '/api/v2/chat/channels/{type}/{id}', pathParams, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/channels/{type}/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteDraft = async (request: {
+  async deleteDraft(request: {
     type: string;
     id: string;
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       parent_id: request?.parent_id,
       user_id: request?.user_id,
@@ -415,7 +448,7 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/chat/channels/{type}/{id}/draft',
       pathParams,
@@ -425,14 +458,14 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getDraft = async (request: {
+  async getDraft(request: {
     type: string;
     id: string;
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<GetDraftResponse>> => {
+  }): Promise<StreamResponse<GetDraftResponse>> {
     const queryParams = {
       parent_id: request?.parent_id,
       user_id: request?.user_id,
@@ -442,7 +475,9 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetDraftResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetDraftResponse>
+    >(
       'GET',
       '/api/v2/chat/channels/{type}/{id}/draft',
       pathParams,
@@ -452,11 +487,11 @@ export class ChatApi extends BaseApi {
     decoders.GetDraftResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  sendEvent = async (
+  async sendEvent(
     request: SendEventRequest & { type: string; id: string },
-  ): Promise<StreamResponse<EventResponse>> => {
+  ): Promise<StreamResponse<EventResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -465,24 +500,27 @@ export class ChatApi extends BaseApi {
       event: request?.event,
     };
 
-    const response = await this.sendRequest<StreamResponse<EventResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<EventResponse>
+    >(
       'POST',
       '/api/v2/chat/channels/{type}/{id}/event',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.EventResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteFile = async (request: {
+  async deleteFile(request: {
     type: string;
     id: string;
     url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       url: request?.url,
     };
@@ -491,7 +529,7 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/chat/channels/{type}/{id}/file',
       pathParams,
@@ -501,11 +539,11 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  uploadFile = async (
+  async uploadFile(
     request: FileUploadRequest & { type: string; id: string },
-  ): Promise<StreamResponse<FileUploadResponse>> => {
+  ): Promise<StreamResponse<FileUploadResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -515,22 +553,25 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<FileUploadResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FileUploadResponse>
+    >(
       'POST',
       '/api/v2/chat/channels/{type}/{id}/file',
       pathParams,
       undefined,
       body,
+      'multipart/form-data',
     );
 
     decoders.FileUploadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  hideChannel = async (
+  async hideChannel(
     request: HideChannelRequest & { type: string; id: string },
-  ): Promise<StreamResponse<HideChannelResponse>> => {
+  ): Promise<StreamResponse<HideChannelResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -541,7 +582,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<HideChannelResponse>
     >(
       'POST',
@@ -549,18 +590,19 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.HideChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteImage = async (request: {
+  async deleteImage(request: {
     type: string;
     id: string;
     url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       url: request?.url,
     };
@@ -569,7 +611,7 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/chat/channels/{type}/{id}/image',
       pathParams,
@@ -579,11 +621,11 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  uploadImage = async (
+  async uploadImage(
     request: ImageUploadRequest & { type: string; id: string },
-  ): Promise<StreamResponse<ImageUploadResponse>> => {
+  ): Promise<StreamResponse<ImageUploadResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -594,7 +636,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ImageUploadResponse>
     >(
       'POST',
@@ -602,20 +644,21 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'multipart/form-data',
     );
 
     decoders.ImageUploadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateMemberPartial = async (
+  async updateMemberPartial(
     request: UpdateMemberPartialRequest & {
       type: string;
       id: string;
       user_id?: string;
     },
-  ): Promise<StreamResponse<UpdateMemberPartialResponse>> => {
+  ): Promise<StreamResponse<UpdateMemberPartialResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
@@ -628,7 +671,7 @@ export class ChatApi extends BaseApi {
       set: request?.set,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateMemberPartialResponse>
     >(
       'PATCH',
@@ -636,16 +679,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       queryParams,
       body,
+      'application/json',
     );
 
     decoders.UpdateMemberPartialResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  sendMessage = async (
+  async sendMessage(
     request: SendMessageRequest & { type: string; id: string },
-  ): Promise<StreamResponse<SendMessageResponse>> => {
+  ): Promise<StreamResponse<SendMessageResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -660,7 +704,7 @@ export class ChatApi extends BaseApi {
       pending_message_metadata: request?.pending_message_metadata,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SendMessageResponse>
     >(
       'POST',
@@ -668,18 +712,19 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.SendMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getManyMessages = async (request: {
+  async getManyMessages(request: {
     type: string;
     id: string;
     ids: string[];
-  }): Promise<StreamResponse<GetManyMessagesResponse>> => {
+  }): Promise<StreamResponse<GetManyMessagesResponse>> {
     const queryParams = {
       ids: request?.ids,
     };
@@ -688,7 +733,7 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetManyMessagesResponse>
     >(
       'GET',
@@ -700,11 +745,11 @@ export class ChatApi extends BaseApi {
     decoders.GetManyMessagesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getOrCreateChannel = async (
+  async getOrCreateChannel(
     request: ChannelGetOrCreateRequest & { type: string; id: string },
-  ): Promise<StreamResponse<ChannelStateResponse>> => {
+  ): Promise<StreamResponse<ChannelStateResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -719,7 +764,7 @@ export class ChatApi extends BaseApi {
       watchers: request?.watchers,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ChannelStateResponse>
     >(
       'POST',
@@ -727,16 +772,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.ChannelStateResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  markRead = async (
+  async markRead(
     request: MarkReadRequest & { type: string; id: string },
-  ): Promise<StreamResponse<MarkReadResponse>> => {
+  ): Promise<StreamResponse<MarkReadResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -748,22 +794,25 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<MarkReadResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MarkReadResponse>
+    >(
       'POST',
       '/api/v2/chat/channels/{type}/{id}/read',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MarkReadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  showChannel = async (
+  async showChannel(
     request: ShowChannelRequest & { type: string; id: string },
-  ): Promise<StreamResponse<ShowChannelResponse>> => {
+  ): Promise<StreamResponse<ShowChannelResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -773,7 +822,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ShowChannelResponse>
     >(
       'POST',
@@ -781,16 +830,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.ShowChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  truncateChannel = async (
+  async truncateChannel(
     request: TruncateChannelRequest & { type: string; id: string },
-  ): Promise<StreamResponse<TruncateChannelResponse>> => {
+  ): Promise<StreamResponse<TruncateChannelResponse>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -805,7 +855,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<TruncateChannelResponse>
     >(
       'POST',
@@ -813,16 +863,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.TruncateChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  markUnread = async (
+  async markUnread(
     request: MarkUnreadRequest & { type: string; id: string },
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const pathParams = {
       type: request?.type,
       id: request?.id,
@@ -834,34 +885,33 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'POST',
       '/api/v2/chat/channels/{type}/{id}/unread',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listChannelTypes = async (): Promise<
-    StreamResponse<ListChannelTypesResponse>
-  > => {
-    const response = await this.sendRequest<
+  async listChannelTypes(): Promise<StreamResponse<ListChannelTypesResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListChannelTypesResponse>
     >('GET', '/api/v2/chat/channeltypes', undefined, undefined);
 
     decoders.ListChannelTypesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createChannelType = async (
+  async createChannelType(
     request: CreateChannelTypeRequest,
-  ): Promise<StreamResponse<CreateChannelTypeResponse>> => {
+  ): Promise<StreamResponse<CreateChannelTypeResponse>> {
     const body = {
       automod: request?.automod,
       automod_behavior: request?.automod_behavior,
@@ -882,6 +932,7 @@ export class ChatApi extends BaseApi {
       read_events: request?.read_events,
       replies: request?.replies,
       search: request?.search,
+      shared_locations: request?.shared_locations,
       skip_last_msg_update_for_system_msgs:
         request?.skip_last_msg_update_for_system_msgs,
       typing_events: request?.typing_events,
@@ -894,23 +945,30 @@ export class ChatApi extends BaseApi {
       grants: request?.grants,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateChannelTypeResponse>
-    >('POST', '/api/v2/chat/channeltypes', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/channeltypes',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateChannelTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteChannelType = async (request: {
+  async deleteChannelType(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/chat/channeltypes/{name}',
       pathParams,
@@ -920,27 +978,27 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getChannelType = async (request: {
+  async getChannelType(request: {
     name: string;
-  }): Promise<StreamResponse<GetChannelTypeResponse>> => {
+  }): Promise<StreamResponse<GetChannelTypeResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetChannelTypeResponse>
     >('GET', '/api/v2/chat/channeltypes/{name}', pathParams, undefined);
 
     decoders.GetChannelTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateChannelType = async (
+  async updateChannelType(
     request: UpdateChannelTypeRequest & { name: string },
-  ): Promise<StreamResponse<UpdateChannelTypeResponse>> => {
+  ): Promise<StreamResponse<UpdateChannelTypeResponse>> {
     const pathParams = {
       name: request?.name,
     };
@@ -964,6 +1022,7 @@ export class ChatApi extends BaseApi {
       reminders: request?.reminders,
       replies: request?.replies,
       search: request?.search,
+      shared_locations: request?.shared_locations,
       skip_last_msg_update_for_system_msgs:
         request?.skip_last_msg_update_for_system_msgs,
       typing_events: request?.typing_events,
@@ -978,28 +1037,35 @@ export class ChatApi extends BaseApi {
       grants: request?.grants,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateChannelTypeResponse>
-    >('PUT', '/api/v2/chat/channeltypes/{name}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/chat/channeltypes/{name}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateChannelTypeResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listCommands = async (): Promise<StreamResponse<ListCommandsResponse>> => {
-    const response = await this.sendRequest<
+  async listCommands(): Promise<StreamResponse<ListCommandsResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListCommandsResponse>
     >('GET', '/api/v2/chat/commands', undefined, undefined);
 
     decoders.ListCommandsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createCommand = async (
+  async createCommand(
     request: CreateCommandRequest,
-  ): Promise<StreamResponse<CreateCommandResponse>> => {
+  ): Promise<StreamResponse<CreateCommandResponse>> {
     const body = {
       description: request?.description,
       name: request?.name,
@@ -1007,53 +1073,57 @@ export class ChatApi extends BaseApi {
       set: request?.set,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateCommandResponse>
-    >('POST', '/api/v2/chat/commands', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/commands',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateCommandResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteCommand = async (request: {
+  async deleteCommand(request: {
     name: string;
-  }): Promise<StreamResponse<DeleteCommandResponse>> => {
+  }): Promise<StreamResponse<DeleteCommandResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteCommandResponse>
     >('DELETE', '/api/v2/chat/commands/{name}', pathParams, undefined);
 
     decoders.DeleteCommandResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getCommand = async (request: {
+  async getCommand(request: {
     name: string;
-  }): Promise<StreamResponse<GetCommandResponse>> => {
+  }): Promise<StreamResponse<GetCommandResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetCommandResponse>>(
-      'GET',
-      '/api/v2/chat/commands/{name}',
-      pathParams,
-      undefined,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetCommandResponse>
+    >('GET', '/api/v2/chat/commands/{name}', pathParams, undefined);
 
     decoders.GetCommandResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateCommand = async (
+  async updateCommand(
     request: UpdateCommandRequest & { name: string },
-  ): Promise<StreamResponse<UpdateCommandResponse>> => {
+  ): Promise<StreamResponse<UpdateCommandResponse>> {
     const pathParams = {
       name: request?.name,
     };
@@ -1063,18 +1133,25 @@ export class ChatApi extends BaseApi {
       set: request?.set,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateCommandResponse>
-    >('PUT', '/api/v2/chat/commands/{name}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/chat/commands/{name}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateCommandResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryDrafts = async (
+  async queryDrafts(
     request?: QueryDraftsRequest,
-  ): Promise<StreamResponse<QueryDraftsResponse>> => {
+  ): Promise<StreamResponse<QueryDraftsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -1085,18 +1162,25 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryDraftsResponse>
-    >('POST', '/api/v2/chat/drafts/query', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/drafts/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryDraftsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  exportChannels = async (
+  async exportChannels(
     request: ExportChannelsRequest,
-  ): Promise<StreamResponse<ExportChannelsResponse>> => {
+  ): Promise<StreamResponse<ExportChannelsResponse>> {
     const body = {
       channels: request?.channels,
       clear_deleted_message_text: request?.clear_deleted_message_text,
@@ -1106,37 +1190,41 @@ export class ChatApi extends BaseApi {
       version: request?.version,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ExportChannelsResponse>
-    >('POST', '/api/v2/chat/export_channels', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/export_channels',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.ExportChannelsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryMembers = async (request?: {
+  async queryMembers(request?: {
     payload?: QueryMembersPayload;
-  }): Promise<StreamResponse<MembersResponse>> => {
+  }): Promise<StreamResponse<MembersResponse>> {
     const queryParams = {
       payload: request?.payload,
     };
 
-    const response = await this.sendRequest<StreamResponse<MembersResponse>>(
-      'GET',
-      '/api/v2/chat/members',
-      undefined,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MembersResponse>
+    >('GET', '/api/v2/chat/members', undefined, queryParams);
 
     decoders.MembersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryMessageHistory = async (
+  async queryMessageHistory(
     request: QueryMessageHistoryRequest,
-  ): Promise<StreamResponse<QueryMessageHistoryResponse>> => {
+  ): Promise<StreamResponse<QueryMessageHistoryResponse>> {
     const body = {
       filter: request?.filter,
       limit: request?.limit,
@@ -1145,20 +1233,27 @@ export class ChatApi extends BaseApi {
       sort: request?.sort,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryMessageHistoryResponse>
-    >('POST', '/api/v2/chat/messages/history', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/messages/history',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryMessageHistoryResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteMessage = async (request: {
+  async deleteMessage(request: {
     id: string;
     hard?: boolean;
     deleted_by?: string;
-  }): Promise<StreamResponse<DeleteMessageResponse>> => {
+  }): Promise<StreamResponse<DeleteMessageResponse>> {
     const queryParams = {
       hard: request?.hard,
       deleted_by: request?.deleted_by,
@@ -1167,19 +1262,19 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteMessageResponse>
     >('DELETE', '/api/v2/chat/messages/{id}', pathParams, queryParams);
 
     decoders.DeleteMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getMessage = async (request: {
+  async getMessage(request: {
     id: string;
     show_deleted_message?: boolean;
-  }): Promise<StreamResponse<GetMessageResponse>> => {
+  }): Promise<StreamResponse<GetMessageResponse>> {
     const queryParams = {
       show_deleted_message: request?.show_deleted_message,
     };
@@ -1187,21 +1282,18 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetMessageResponse>>(
-      'GET',
-      '/api/v2/chat/messages/{id}',
-      pathParams,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetMessageResponse>
+    >('GET', '/api/v2/chat/messages/{id}', pathParams, queryParams);
 
     decoders.GetMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateMessage = async (
+  async updateMessage(
     request: UpdateMessageRequest & { id: string },
-  ): Promise<StreamResponse<UpdateMessageResponse>> => {
+  ): Promise<StreamResponse<UpdateMessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1211,18 +1303,25 @@ export class ChatApi extends BaseApi {
       skip_push: request?.skip_push,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateMessageResponse>
-    >('POST', '/api/v2/chat/messages/{id}', pathParams, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/messages/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateMessagePartial = async (
+  async updateMessagePartial(
     request: UpdateMessagePartialRequest & { id: string },
-  ): Promise<StreamResponse<UpdateMessagePartialResponse>> => {
+  ): Promise<StreamResponse<UpdateMessagePartialResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1234,18 +1333,25 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateMessagePartialResponse>
-    >('PUT', '/api/v2/chat/messages/{id}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/chat/messages/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateMessagePartialResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  runMessageAction = async (
+  async runMessageAction(
     request: MessageActionRequest & { id: string },
-  ): Promise<StreamResponse<MessageResponse>> => {
+  ): Promise<StreamResponse<MessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1255,43 +1361,49 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<MessageResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MessageResponse>
+    >(
       'POST',
       '/api/v2/chat/messages/{id}/action',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  commitMessage = async (
+  async commitMessage(
     request: CommitMessageRequest & { id: string },
-  ): Promise<StreamResponse<MessageResponse>> => {
+  ): Promise<StreamResponse<MessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
     const body = {};
 
-    const response = await this.sendRequest<StreamResponse<MessageResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MessageResponse>
+    >(
       'POST',
       '/api/v2/chat/messages/{id}/commit',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  sendReaction = async (
+  async sendReaction(
     request: SendReactionRequest & { id: string },
-  ): Promise<StreamResponse<SendReactionResponse>> => {
+  ): Promise<StreamResponse<SendReactionResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1301,7 +1413,7 @@ export class ChatApi extends BaseApi {
       skip_push: request?.skip_push,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SendReactionResponse>
     >(
       'POST',
@@ -1309,18 +1421,19 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.SendReactionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteReaction = async (request: {
+  async deleteReaction(request: {
     id: string;
     type: string;
     user_id?: string;
-  }): Promise<StreamResponse<DeleteReactionResponse>> => {
+  }): Promise<StreamResponse<DeleteReactionResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
@@ -1329,7 +1442,7 @@ export class ChatApi extends BaseApi {
       type: request?.type,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteReactionResponse>
     >(
       'DELETE',
@@ -1341,13 +1454,13 @@ export class ChatApi extends BaseApi {
     decoders.DeleteReactionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getReactions = async (request: {
+  async getReactions(request: {
     id: string;
     limit?: number;
     offset?: number;
-  }): Promise<StreamResponse<GetReactionsResponse>> => {
+  }): Promise<StreamResponse<GetReactionsResponse>> {
     const queryParams = {
       limit: request?.limit,
       offset: request?.offset,
@@ -1356,18 +1469,18 @@ export class ChatApi extends BaseApi {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetReactionsResponse>
     >('GET', '/api/v2/chat/messages/{id}/reactions', pathParams, queryParams);
 
     decoders.GetReactionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryReactions = async (
+  async queryReactions(
     request: QueryReactionsRequest & { id: string },
-  ): Promise<StreamResponse<QueryReactionsResponse>> => {
+  ): Promise<StreamResponse<QueryReactionsResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1381,7 +1494,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryReactionsResponse>
     >(
       'POST',
@@ -1389,16 +1502,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.QueryReactionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  translateMessage = async (
+  async translateMessage(
     request: TranslateMessageRequest & { id: string },
-  ): Promise<StreamResponse<MessageResponse>> => {
+  ): Promise<StreamResponse<MessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1406,22 +1520,25 @@ export class ChatApi extends BaseApi {
       language: request?.language,
     };
 
-    const response = await this.sendRequest<StreamResponse<MessageResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MessageResponse>
+    >(
       'POST',
       '/api/v2/chat/messages/{id}/translate',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  undeleteMessage = async (
+  async undeleteMessage(
     request: UpdateMessageRequest & { id: string },
-  ): Promise<StreamResponse<UpdateMessageResponse>> => {
+  ): Promise<StreamResponse<UpdateMessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -1431,7 +1548,7 @@ export class ChatApi extends BaseApi {
       skip_push: request?.skip_push,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateMessageResponse>
     >(
       'POST',
@@ -1439,16 +1556,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  castPollVote = async (
+  async castPollVote(
     request: CastPollVoteRequest & { message_id: string; poll_id: string },
-  ): Promise<StreamResponse<PollVoteResponse>> => {
+  ): Promise<StreamResponse<PollVoteResponse>> {
     const pathParams = {
       message_id: request?.message_id,
       poll_id: request?.poll_id,
@@ -1459,25 +1577,28 @@ export class ChatApi extends BaseApi {
       vote: request?.vote,
     };
 
-    const response = await this.sendRequest<StreamResponse<PollVoteResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PollVoteResponse>
+    >(
       'POST',
       '/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.PollVoteResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  removePollVote = async (request: {
+  async deletePollVote(request: {
     message_id: string;
     poll_id: string;
     vote_id: string;
     user_id?: string;
-  }): Promise<StreamResponse<PollVoteResponse>> => {
+  }): Promise<StreamResponse<PollVoteResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
@@ -1487,7 +1608,9 @@ export class ChatApi extends BaseApi {
       vote_id: request?.vote_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<PollVoteResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PollVoteResponse>
+    >(
       'DELETE',
       '/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote/{vote_id}',
       pathParams,
@@ -1497,12 +1620,12 @@ export class ChatApi extends BaseApi {
     decoders.PollVoteResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteReminder = async (request: {
+  async deleteReminder(request: {
     message_id: string;
     user_id?: string;
-  }): Promise<StreamResponse<DeleteReminderResponse>> => {
+  }): Promise<StreamResponse<DeleteReminderResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
@@ -1510,7 +1633,7 @@ export class ChatApi extends BaseApi {
       message_id: request?.message_id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteReminderResponse>
     >(
       'DELETE',
@@ -1522,11 +1645,11 @@ export class ChatApi extends BaseApi {
     decoders.DeleteReminderResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateReminder = async (
+  async updateReminder(
     request: UpdateReminderRequest & { message_id: string },
-  ): Promise<StreamResponse<UpdateReminderResponse>> => {
+  ): Promise<StreamResponse<UpdateReminderResponse>> {
     const pathParams = {
       message_id: request?.message_id,
     };
@@ -1536,7 +1659,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateReminderResponse>
     >(
       'PATCH',
@@ -1544,16 +1667,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateReminderResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createReminder = async (
+  async createReminder(
     request: CreateReminderRequest & { message_id: string },
-  ): Promise<StreamResponse<ReminderResponseData>> => {
+  ): Promise<StreamResponse<ReminderResponseData>> {
     const pathParams = {
       message_id: request?.message_id,
     };
@@ -1563,7 +1687,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ReminderResponseData>
     >(
       'POST',
@@ -1571,14 +1695,15 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.ReminderResponseData?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getReplies = async (request: {
+  async getReplies(request: {
     parent_id: string;
     limit?: number;
     offset?: number;
@@ -1593,7 +1718,7 @@ export class ChatApi extends BaseApi {
     id_around?: string;
     created_at_around?: Date;
     sort?: SortParamRequest[];
-  }): Promise<StreamResponse<GetRepliesResponse>> => {
+  }): Promise<StreamResponse<GetRepliesResponse>> {
     const queryParams = {
       limit: request?.limit,
       offset: request?.offset,
@@ -1613,7 +1738,9 @@ export class ChatApi extends BaseApi {
       parent_id: request?.parent_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetRepliesResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetRepliesResponse>
+    >(
       'GET',
       '/api/v2/chat/messages/{parent_id}/replies',
       pathParams,
@@ -1623,27 +1750,27 @@ export class ChatApi extends BaseApi {
     decoders.GetRepliesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryMessageFlags = async (request?: {
+  async queryMessageFlags(request?: {
     payload?: QueryMessageFlagsPayload;
-  }): Promise<StreamResponse<QueryMessageFlagsResponse>> => {
+  }): Promise<StreamResponse<QueryMessageFlagsResponse>> {
     const queryParams = {
       payload: request?.payload,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryMessageFlagsResponse>
     >('GET', '/api/v2/chat/moderation/flags/message', undefined, queryParams);
 
     decoders.QueryMessageFlagsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  muteChannel = async (
+  async muteChannel(
     request?: MuteChannelRequest,
-  ): Promise<StreamResponse<MuteChannelResponse>> => {
+  ): Promise<StreamResponse<MuteChannelResponse>> {
     const body = {
       expiration: request?.expiration,
       user_id: request?.user_id,
@@ -1651,7 +1778,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<MuteChannelResponse>
     >(
       'POST',
@@ -1659,16 +1786,17 @@ export class ChatApi extends BaseApi {
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MuteChannelResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unmuteChannel = async (
+  async unmuteChannel(
     request?: UnmuteChannelRequest,
-  ): Promise<StreamResponse<UnmuteResponse>> => {
+  ): Promise<StreamResponse<UnmuteResponse>> {
     const body = {
       expiration: request?.expiration,
       user_id: request?.user_id,
@@ -1676,353 +1804,66 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<UnmuteResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnmuteResponse>
+    >(
       'POST',
       '/api/v2/chat/moderation/unmute/channel',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UnmuteResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
-
-  createPoll = async (
-    request: CreatePollRequest,
-  ): Promise<StreamResponse<PollResponse>> => {
-    const body = {
-      name: request?.name,
-      allow_answers: request?.allow_answers,
-      allow_user_suggested_options: request?.allow_user_suggested_options,
-      description: request?.description,
-      enforce_unique_vote: request?.enforce_unique_vote,
-      id: request?.id,
-      is_closed: request?.is_closed,
-      max_votes_allowed: request?.max_votes_allowed,
-      user_id: request?.user_id,
-      voting_visibility: request?.voting_visibility,
-      options: request?.options,
-      custom: request?.custom,
-      user: request?.user,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollResponse>>(
-      'POST',
-      '/api/v2/chat/polls',
-      undefined,
-      undefined,
-      body,
-    );
-
-    decoders.PollResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  updatePoll = async (
-    request: UpdatePollRequest,
-  ): Promise<StreamResponse<PollResponse>> => {
-    const body = {
-      id: request?.id,
-      name: request?.name,
-      allow_answers: request?.allow_answers,
-      allow_user_suggested_options: request?.allow_user_suggested_options,
-      description: request?.description,
-      enforce_unique_vote: request?.enforce_unique_vote,
-      is_closed: request?.is_closed,
-      max_votes_allowed: request?.max_votes_allowed,
-      user_id: request?.user_id,
-      voting_visibility: request?.voting_visibility,
-      options: request?.options,
-      custom: request?.custom,
-      user: request?.user,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollResponse>>(
-      'PUT',
-      '/api/v2/chat/polls',
-      undefined,
-      undefined,
-      body,
-    );
-
-    decoders.PollResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  queryPolls = async (
-    request?: QueryPollsRequest & { user_id?: string },
-  ): Promise<StreamResponse<QueryPollsResponse>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const body = {
-      limit: request?.limit,
-      next: request?.next,
-      prev: request?.prev,
-      sort: request?.sort,
-      filter: request?.filter,
-    };
-
-    const response = await this.sendRequest<StreamResponse<QueryPollsResponse>>(
-      'POST',
-      '/api/v2/chat/polls/query',
-      undefined,
-      queryParams,
-      body,
-    );
-
-    decoders.QueryPollsResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  deletePoll = async (request: {
-    poll_id: string;
-    user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
-
-    const response = await this.sendRequest<StreamResponse<Response>>(
-      'DELETE',
-      '/api/v2/chat/polls/{poll_id}',
-      pathParams,
-      queryParams,
-    );
-
-    decoders.Response?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  getPoll = async (request: {
-    poll_id: string;
-    user_id?: string;
-  }): Promise<StreamResponse<PollResponse>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollResponse>>(
-      'GET',
-      '/api/v2/chat/polls/{poll_id}',
-      pathParams,
-      queryParams,
-    );
-
-    decoders.PollResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  updatePollPartial = async (
-    request: UpdatePollPartialRequest & { poll_id: string },
-  ): Promise<StreamResponse<PollResponse>> => {
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
-    const body = {
-      user_id: request?.user_id,
-      unset: request?.unset,
-      set: request?.set,
-      user: request?.user,
-    };
+  }
 
-    const response = await this.sendRequest<StreamResponse<PollResponse>>(
-      'PATCH',
-      '/api/v2/chat/polls/{poll_id}',
-      pathParams,
-      undefined,
-      body,
-    );
-
-    decoders.PollResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  createPollOption = async (
-    request: CreatePollOptionRequest & { poll_id: string },
-  ): Promise<StreamResponse<PollOptionResponse>> => {
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
+  async updatePushNotificationPreferences(
+    request: UpsertPushPreferencesRequest,
+  ): Promise<StreamResponse<UpsertPushPreferencesResponse>> {
     const body = {
-      text: request?.text,
-      position: request?.position,
-      user_id: request?.user_id,
-      custom: request?.custom,
-      user: request?.user,
+      preferences: request?.preferences,
     };
 
-    const response = await this.sendRequest<StreamResponse<PollOptionResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpsertPushPreferencesResponse>
+    >(
       'POST',
-      '/api/v2/chat/polls/{poll_id}/options',
-      pathParams,
+      '/api/v2/chat/push_preferences',
       undefined,
-      body,
-    );
-
-    decoders.PollOptionResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  updatePollOption = async (
-    request: UpdatePollOptionRequest & { poll_id: string },
-  ): Promise<StreamResponse<PollOptionResponse>> => {
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
-    const body = {
-      id: request?.id,
-      text: request?.text,
-      user_id: request?.user_id,
-      custom: request?.custom,
-      user: request?.user,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollOptionResponse>>(
-      'PUT',
-      '/api/v2/chat/polls/{poll_id}/options',
-      pathParams,
       undefined,
       body,
+      'application/json',
     );
 
-    decoders.PollOptionResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  deletePollOption = async (request: {
-    poll_id: string;
-    option_id: string;
-    user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const pathParams = {
-      poll_id: request?.poll_id,
-      option_id: request?.option_id,
-    };
-
-    const response = await this.sendRequest<StreamResponse<Response>>(
-      'DELETE',
-      '/api/v2/chat/polls/{poll_id}/options/{option_id}',
-      pathParams,
-      queryParams,
-    );
-
-    decoders.Response?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  getPollOption = async (request: {
-    poll_id: string;
-    option_id: string;
-    user_id?: string;
-  }): Promise<StreamResponse<PollOptionResponse>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const pathParams = {
-      poll_id: request?.poll_id,
-      option_id: request?.option_id,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollOptionResponse>>(
-      'GET',
-      '/api/v2/chat/polls/{poll_id}/options/{option_id}',
-      pathParams,
-      queryParams,
-    );
-
-    decoders.PollOptionResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  queryPollVotes = async (
-    request: QueryPollVotesRequest & { poll_id: string; user_id?: string },
-  ): Promise<StreamResponse<PollVotesResponse>> => {
-    const queryParams = {
-      user_id: request?.user_id,
-    };
-    const pathParams = {
-      poll_id: request?.poll_id,
-    };
-    const body = {
-      limit: request?.limit,
-      next: request?.next,
-      prev: request?.prev,
-      sort: request?.sort,
-      filter: request?.filter,
-    };
-
-    const response = await this.sendRequest<StreamResponse<PollVotesResponse>>(
-      'POST',
-      '/api/v2/chat/polls/{poll_id}/votes',
-      pathParams,
-      queryParams,
-      body,
-    );
-
-    decoders.PollVotesResponse?.(response.body);
-
-    return { ...response.body, metadata: response.metadata };
-  };
-
-  updatePushNotificationPreferences = async (
-    request: UpsertPushPreferencesRequest,
-  ): Promise<StreamResponse<UpsertPushPreferencesResponse>> => {
-    const body = {
-      preferences: request?.preferences,
-    };
-
-    const response = await this.sendRequest<
-      StreamResponse<UpsertPushPreferencesResponse>
-    >('POST', '/api/v2/chat/push_preferences', undefined, undefined, body);
-
     decoders.UpsertPushPreferencesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getPushTemplates = async (request: {
+  async getPushTemplates(request: {
     push_provider_type: string;
     push_provider_name?: string;
-  }): Promise<StreamResponse<GetPushTemplatesResponse>> => {
+  }): Promise<StreamResponse<GetPushTemplatesResponse>> {
     const queryParams = {
       push_provider_type: request?.push_provider_type,
       push_provider_name: request?.push_provider_name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetPushTemplatesResponse>
     >('GET', '/api/v2/chat/push_templates', undefined, queryParams);
 
     decoders.GetPushTemplatesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  upsertPushTemplate = async (
+  async upsertPushTemplate(
     request: UpsertPushTemplateRequest,
-  ): Promise<StreamResponse<UpsertPushTemplateResponse>> => {
+  ): Promise<StreamResponse<UpsertPushTemplateResponse>> {
     const body = {
       event_type: request?.event_type,
       push_provider_type: request?.push_provider_type,
@@ -2031,34 +1872,41 @@ export class ChatApi extends BaseApi {
       template: request?.template,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpsertPushTemplateResponse>
-    >('POST', '/api/v2/chat/push_templates', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/push_templates',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpsertPushTemplateResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryBannedUsers = async (request?: {
+  async queryBannedUsers(request?: {
     payload?: QueryBannedUsersPayload;
-  }): Promise<StreamResponse<QueryBannedUsersResponse>> => {
+  }): Promise<StreamResponse<QueryBannedUsersResponse>> {
     const queryParams = {
       payload: request?.payload,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryBannedUsersResponse>
     >('GET', '/api/v2/chat/query_banned_users', undefined, queryParams);
 
     decoders.QueryBannedUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryReminders = async (
+  async queryReminders(
     request?: QueryRemindersRequest,
-  ): Promise<StreamResponse<QueryRemindersResponse>> => {
+  ): Promise<StreamResponse<QueryRemindersResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -2069,37 +1917,41 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryRemindersResponse>
-    >('POST', '/api/v2/chat/reminders/query', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/reminders/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryRemindersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  search = async (request?: {
+  async search(request?: {
     payload?: SearchPayload;
-  }): Promise<StreamResponse<SearchResponse>> => {
+  }): Promise<StreamResponse<SearchResponse>> {
     const queryParams = {
       payload: request?.payload,
     };
 
-    const response = await this.sendRequest<StreamResponse<SearchResponse>>(
-      'GET',
-      '/api/v2/chat/search',
-      undefined,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<SearchResponse>
+    >('GET', '/api/v2/chat/search', undefined, queryParams);
 
     decoders.SearchResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  querySegments = async (
+  async querySegments(
     request: QuerySegmentsRequest,
-  ): Promise<StreamResponse<QuerySegmentsResponse>> => {
+  ): Promise<StreamResponse<QuerySegmentsResponse>> {
     const body = {
       filter: request?.filter,
       limit: request?.limit,
@@ -2108,23 +1960,30 @@ export class ChatApi extends BaseApi {
       sort: request?.sort,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QuerySegmentsResponse>
-    >('POST', '/api/v2/chat/segments/query', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/segments/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QuerySegmentsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteSegment = async (request: {
+  async deleteSegment(request: {
     id: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/chat/segments/{id}',
       pathParams,
@@ -2134,30 +1993,27 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getSegment = async (request: {
+  async getSegment(request: {
     id: string;
-  }): Promise<StreamResponse<GetSegmentResponse>> => {
+  }): Promise<StreamResponse<GetSegmentResponse>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetSegmentResponse>>(
-      'GET',
-      '/api/v2/chat/segments/{id}',
-      pathParams,
-      undefined,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetSegmentResponse>
+    >('GET', '/api/v2/chat/segments/{id}', pathParams, undefined);
 
     decoders.GetSegmentResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteSegmentTargets = async (
+  async deleteSegmentTargets(
     request: DeleteSegmentTargetsRequest & { id: string },
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const pathParams = {
       id: request?.id,
     };
@@ -2165,29 +2021,30 @@ export class ChatApi extends BaseApi {
       target_ids: request?.target_ids,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'POST',
       '/api/v2/chat/segments/{id}/deletetargets',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  segmentTargetExists = async (request: {
+  async segmentTargetExists(request: {
     id: string;
     target_id: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const pathParams = {
       id: request?.id,
       target_id: request?.target_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'GET',
       '/api/v2/chat/segments/{id}/target/{target_id}',
       pathParams,
@@ -2197,11 +2054,11 @@ export class ChatApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  querySegmentTargets = async (
+  async querySegmentTargets(
     request: QuerySegmentTargetsRequest & { id: string },
-  ): Promise<StreamResponse<QuerySegmentTargetsResponse>> => {
+  ): Promise<StreamResponse<QuerySegmentTargetsResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -2213,7 +2070,7 @@ export class ChatApi extends BaseApi {
       filter: request?.filter,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QuerySegmentTargetsResponse>
     >(
       'POST',
@@ -2221,16 +2078,17 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.QuerySegmentTargetsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryThreads = async (
+  async queryThreads(
     request?: QueryThreadsRequest,
-  ): Promise<StreamResponse<QueryThreadsResponse>> => {
+  ): Promise<StreamResponse<QueryThreadsResponse>> {
     const body = {
       limit: request?.limit,
       member_limit: request?.member_limit,
@@ -2244,21 +2102,28 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryThreadsResponse>
-    >('POST', '/api/v2/chat/threads', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/threads',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryThreadsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getThread = async (request: {
+  async getThread(request: {
     message_id: string;
     reply_limit?: number;
     participant_limit?: number;
     member_limit?: number;
-  }): Promise<StreamResponse<GetThreadResponse>> => {
+  }): Promise<StreamResponse<GetThreadResponse>> {
     const queryParams = {
       reply_limit: request?.reply_limit,
       participant_limit: request?.participant_limit,
@@ -2268,21 +2133,18 @@ export class ChatApi extends BaseApi {
       message_id: request?.message_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetThreadResponse>>(
-      'GET',
-      '/api/v2/chat/threads/{message_id}',
-      pathParams,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetThreadResponse>
+    >('GET', '/api/v2/chat/threads/{message_id}', pathParams, queryParams);
 
     decoders.GetThreadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateThreadPartial = async (
+  async updateThreadPartial(
     request: UpdateThreadPartialRequest & { message_id: string },
-  ): Promise<StreamResponse<UpdateThreadPartialResponse>> => {
+  ): Promise<StreamResponse<UpdateThreadPartialResponse>> {
     const pathParams = {
       message_id: request?.message_id,
     };
@@ -2293,7 +2155,7 @@ export class ChatApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateThreadPartialResponse>
     >(
       'PATCH',
@@ -2301,44 +2163,50 @@ export class ChatApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpdateThreadPartialResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unreadCounts = async (): Promise<
-    StreamResponse<WrappedUnreadCountsResponse>
-  > => {
-    const response = await this.sendRequest<
+  async unreadCounts(): Promise<StreamResponse<WrappedUnreadCountsResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<WrappedUnreadCountsResponse>
     >('GET', '/api/v2/chat/unread', undefined, undefined);
 
     decoders.WrappedUnreadCountsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unreadCountsBatch = async (
+  async unreadCountsBatch(
     request: UnreadCountsBatchRequest,
-  ): Promise<StreamResponse<UnreadCountsBatchResponse>> => {
+  ): Promise<StreamResponse<UnreadCountsBatchResponse>> {
     const body = {
       user_ids: request?.user_ids,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UnreadCountsBatchResponse>
-    >('POST', '/api/v2/chat/unread_batch', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/chat/unread_batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UnreadCountsBatchResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  sendUserCustomEvent = async (
+  async sendUserCustomEvent(
     request: SendUserCustomEventRequest & { user_id: string },
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const pathParams = {
       user_id: request?.user_id,
     };
@@ -2346,16 +2214,17 @@ export class ChatApi extends BaseApi {
       event: request?.event,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'POST',
       '/api/v2/chat/users/{user_id}/event',
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 }