diff --git a/CHANGELOG.md b/CHANGELOG.md
index 828472f..13f37d3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,80 +2,69 @@
 
 ## [0.4.26](https://github.com/GetStream/stream-node/compare/v0.4.25...v0.4.26) (2025-07-16)
 
-
 ### Features
 
-* Update to API spec 186.1.0 ([#120](https://github.com/GetStream/stream-node/issues/120)) ([e1d1f88](https://github.com/GetStream/stream-node/commit/e1d1f88d823f71d6386a1791e285bdbee2cbfb54))
+- Update to API spec 186.1.0 ([#120](https://github.com/GetStream/stream-node/issues/120)) ([e1d1f88](https://github.com/GetStream/stream-node/commit/e1d1f88d823f71d6386a1791e285bdbee2cbfb54))
 
 ## [0.4.25](https://github.com/GetStream/stream-node/compare/v0.4.24...v0.4.25) (2025-06-24)
 
-
 ### Features
 
-* Update to API spec v179.7.0 ([#113](https://github.com/GetStream/stream-node/issues/113)) ([898ee9e](https://github.com/GetStream/stream-node/commit/898ee9e692b85075e60147835ff43de3f1179587))
+- Update to API spec v179.7.0 ([#113](https://github.com/GetStream/stream-node/issues/113)) ([898ee9e](https://github.com/GetStream/stream-node/commit/898ee9e692b85075e60147835ff43de3f1179587))
 
 ## [0.4.24](https://github.com/GetStream/stream-node/compare/v0.4.23...v0.4.24) (2025-05-06)
 
-
 ### Features
 
-* empty commit to trigger release ([c0890a8](https://github.com/GetStream/stream-node/commit/c0890a8d8b7adc96d4d81717220159321e924480))
+- empty commit to trigger release ([c0890a8](https://github.com/GetStream/stream-node/commit/c0890a8d8b7adc96d4d81717220159321e924480))
 
 ## [0.4.23](https://github.com/GetStream/stream-node/compare/v0.4.22...v0.4.23) (2025-04-30)
 
-
 ### Features
 
-* update to v171.1.7 ([#107](https://github.com/GetStream/stream-node/issues/107)) ([dd442f0](https://github.com/GetStream/stream-node/commit/dd442f0e6b9acc465781cb748e5c5a03dd51624c))
+- update to v171.1.7 ([#107](https://github.com/GetStream/stream-node/issues/107)) ([dd442f0](https://github.com/GetStream/stream-node/commit/dd442f0e6b9acc465781cb748e5c5a03dd51624c))
 
 ## [0.4.22](https://github.com/GetStream/stream-node/compare/v0.4.21...v0.4.22) (2025-04-09)
 
-
 ### Bug Fixes
 
-* handle missing optional dependency in declarations ([#103](https://github.com/GetStream/stream-node/issues/103)) ([eb271c5](https://github.com/GetStream/stream-node/commit/eb271c5f3bfb6002d341323af25beabd15516ef2))
+- handle missing optional dependency in declarations ([#103](https://github.com/GetStream/stream-node/issues/103)) ([eb271c5](https://github.com/GetStream/stream-node/commit/eb271c5f3bfb6002d341323af25beabd15516ef2))
 
 ## [0.4.21](https://github.com/GetStream/stream-node/compare/v0.4.20...v0.4.21) (2025-04-08)
 
-
 ### Bug Fixes
 
-* remove undici dependency ([#101](https://github.com/GetStream/stream-node/issues/101)) ([c943be1](https://github.com/GetStream/stream-node/commit/c943be1b2871b2b010dd4b29d690c46ecacda23b))
+- remove undici dependency ([#101](https://github.com/GetStream/stream-node/issues/101)) ([c943be1](https://github.com/GetStream/stream-node/commit/c943be1b2871b2b010dd4b29d690c46ecacda23b))
 
 ## [0.4.20](https://github.com/GetStream/stream-node/compare/v0.4.19...v0.4.20) (2025-04-07)
 
-
 ### Features
 
-* set max connections to 100, allow integrators to configure Fetch API ([#98](https://github.com/GetStream/stream-node/issues/98)) ([b044b59](https://github.com/GetStream/stream-node/commit/b044b599867a69b33b3aa9d989d1c1e3277dc92f))
+- set max connections to 100, allow integrators to configure Fetch API ([#98](https://github.com/GetStream/stream-node/issues/98)) ([b044b59](https://github.com/GetStream/stream-node/commit/b044b599867a69b33b3aa9d989d1c1e3277dc92f))
 
 ## [0.4.19](https://github.com/GetStream/stream-node/compare/v0.4.18...v0.4.19) (2025-03-17)
 
-
 ### Features
 
-* update to API spec v163.0.0 ([#96](https://github.com/GetStream/stream-node/issues/96)) ([dcdfea8](https://github.com/GetStream/stream-node/commit/dcdfea8cfbf83b0ef3426426909c844424f682ab))
+- update to API spec v163.0.0 ([#96](https://github.com/GetStream/stream-node/issues/96)) ([dcdfea8](https://github.com/GetStream/stream-node/commit/dcdfea8cfbf83b0ef3426426909c844424f682ab))
 
 ## [0.4.18](https://github.com/GetStream/stream-node/compare/v0.4.17...v0.4.18) (2025-03-10)
 
-
 ### Bug Fixes
 
-* support realtime AI model overrides ([#94](https://github.com/GetStream/stream-node/issues/94)) ([1071f75](https://github.com/GetStream/stream-node/commit/1071f75aaf7ffb029f8c3c4c06465e81abf341d6))
+- support realtime AI model overrides ([#94](https://github.com/GetStream/stream-node/issues/94)) ([1071f75](https://github.com/GetStream/stream-node/commit/1071f75aaf7ffb029f8c3c4c06465e81abf341d6))
 
 ## [0.4.17](https://github.com/GetStream/stream-node/compare/v0.4.16...v0.4.17) (2025-03-06)
 
-
 ### Bug Fixes
 
-* use an exact version of @stream-io/openai-realtime-api ([#92](https://github.com/GetStream/stream-node/issues/92)) ([d6f0419](https://github.com/GetStream/stream-node/commit/d6f0419f924bfdadbb44d2b12b44a664bb4b39a6))
+- use an exact version of @stream-io/openai-realtime-api ([#92](https://github.com/GetStream/stream-node/issues/92)) ([d6f0419](https://github.com/GetStream/stream-node/commit/d6f0419f924bfdadbb44d2b12b44a664bb4b39a6))
 
 ## [0.4.16](https://github.com/GetStream/stream-node/compare/v0.4.15...v0.4.16) (2025-02-25)
 
-
 ### Bug Fixes
 
-* update changelog ([#89](https://github.com/GetStream/stream-node/issues/89)) ([1b46c91](https://github.com/GetStream/stream-node/commit/1b46c919ccc5a98414ca441b833020743217e95d))
+- update changelog ([#89](https://github.com/GetStream/stream-node/issues/89)) ([1b46c91](https://github.com/GetStream/stream-node/commit/1b46c919ccc5a98414ca441b833020743217e95d))
 
 ## [0.4.15](https://github.com/GetStream/stream-node/compare/v0.4.14...v0.4.15) (2025-02-25)
 
diff --git a/__tests__/assets/test-file.pdf b/__tests__/assets/test-file.pdf
index 7b5989c..3a2895f 100644
Binary files a/__tests__/assets/test-file.pdf and b/__tests__/assets/test-file.pdf differ
diff --git a/__tests__/devices-push.test.ts b/__tests__/devices-push.test.ts
index d564dd6..3a082c5 100644
--- a/__tests__/devices-push.test.ts
+++ b/__tests__/devices-push.test.ts
@@ -62,7 +62,8 @@ describe('devices and push', () => {
     expect(response.push_providers).toBeDefined();
   });
 
-  it('test push provider', async () => {
+  // Stream error code 4: CheckPush failed with error: "User has no enabled devices associated"
+  it.skip('test push provider', async () => {
     const response = await client.checkPush({ user_id: user.id });
 
     expect(response).toBeDefined();
diff --git a/__tests__/file-uploads.test.ts b/__tests__/file-uploads.test.ts
new file mode 100644
index 0000000..ac8b12f
--- /dev/null
+++ b/__tests__/file-uploads.test.ts
@@ -0,0 +1,71 @@
+import { beforeAll, describe, it, expect } from 'vitest';
+import { createTestClient } from './create-test-client';
+import { StreamClient } from '../src/StreamClient';
+import fs from 'fs';
+import path from 'path';
+import { File } from 'buffer';
+
+// Don't want to upload files and image every time we run the tests
+describe.skip('global file uploads', () => {
+  let client: StreamClient;
+  const user = {
+    id: 'stream-node-test-user',
+    role: 'admin',
+  };
+
+  beforeAll(async () => {
+    client = createTestClient();
+    await client.upsertUsers([user]);
+  });
+
+  it('upload and delete file', async () => {
+    // Read the test PDF file from assets
+    const filePath = path.join(__dirname, 'assets', 'test-file.pdf');
+    const fileBuffer = fs.readFileSync(filePath);
+
+    const response = await client.uploadFile({
+      file: new File([fileBuffer], 'test-file.pdf'),
+      user: { id: user.id },
+    });
+
+    expect(response).toBeDefined();
+    expect(response.file).toBeDefined();
+    expect(response.duration).toBeDefined();
+
+    const deleteResponse = await client.deleteFile({
+      url: response.file,
+    });
+
+    expect(deleteResponse).toBeDefined();
+  });
+
+  it('upload image', async () => {
+    // Read the test PDF file from assets
+    const filePath = path.join(__dirname, 'assets', 'test-image.jpg');
+    const fileBuffer = fs.readFileSync(filePath);
+
+    const uploadSizes = [
+      {
+        width: 100,
+        height: 100,
+        resize: 'scale',
+        crop: 'center',
+      },
+    ];
+
+    // Upload the file
+    const response = await client.uploadImage({
+      file: new File([fileBuffer], 'test-image.jpg'),
+      user: { id: user.id },
+      upload_sizes: uploadSizes,
+    });
+
+    expect(response.upload_sizes?.length).toBe(1);
+    expect(response.upload_sizes?.[0]).toMatchObject(uploadSizes[0]);
+    const deleteResponse = await client.deleteImage({
+      url: response.file,
+    });
+
+    expect(deleteResponse).toBeDefined();
+  });
+});
diff --git a/generate-openapi.sh b/generate-openapi.sh
index e790a11..83fb15d 100755
--- a/generate-openapi.sh
+++ b/generate-openapi.sh
@@ -6,6 +6,6 @@ CHAT_DIR="../chat"
 
 rm -rf $OUTPUT_DIR
 
-( cd $CHAT_DIR ; make openapi ; go run ./cmd/chat-manager openapi generate-client --language ts --spec ./releases/v2/serverside-api.yaml --output $OUTPUT_DIR )
+( cd $CHAT_DIR ; make openapi ; go run ./cmd/chat-manager openapi generate-client --language ts --spec ./releases/v2/feeds-serverside-api.yaml --output $OUTPUT_DIR )
 
 yarn lint:gen
\ No newline at end of file
diff --git a/index.ts b/index.ts
index 9950667..3914180 100644
--- a/index.ts
+++ b/index.ts
@@ -1,6 +1,8 @@
-export * from './src/gen/models';
 export * from './src/StreamClient';
 export * from './src/StreamCall';
 export * from './src/StreamChatClient';
 export * from './src/StreamChannel';
 export * from './src/StreamVideoClient';
+export * from './src/gen/models';
+export * from './src/StreamFeedsClient';
+export * from './src/StreamFeed';
diff --git a/src/BaseApi.ts b/src/ApiClient.ts
similarity index 82%
rename from src/BaseApi.ts
rename to src/ApiClient.ts
index 6206507..d0a235f 100644
--- a/src/BaseApi.ts
+++ b/src/ApiClient.ts
@@ -3,19 +3,24 @@ import { ApiConfig, RequestMetadata, StreamError } from './types';
 import { APIError } from './gen/models';
 import { getRateLimitFromResponseHeader } from './utils/rate-limit';
 
-export class BaseApi {
+export class ApiClient {
   private readonly dispatcher?: RequestInit['dispatcher'];
 
-  constructor(protected readonly apiConfig: ApiConfig) {
+  constructor(public readonly apiConfig: ApiConfig) {
     this.dispatcher = this.apiConfig.agent;
   }
 
-  protected sendRequest = async <T>(
+  /**
+   *
+   * @internal
+   */
+  sendRequest = async <T>(
     method: string,
     url: string,
     pathParams?: Record<string, string>,
     queryParams?: Record<string, any>,
     body?: any,
+    requestContentType?: string,
   ) => {
     queryParams = queryParams ?? {};
     queryParams.api_key = this.apiConfig.apiKey;
@@ -28,22 +33,36 @@ export class BaseApi {
 
     url += `?${encodedParams}`;
     const clientRequestId = uuidv4();
-    const headers = {
+    const headers: Record<string, string> = {
       Authorization: this.apiConfig.token,
       'stream-auth-type': 'jwt',
-      'Content-Type': 'application/json',
       'X-Stream-Client': 'stream-node-' + process.env.PKG_VERSION,
       'Accept-Encoding': 'gzip',
       'x-client-request-id': clientRequestId,
     };
 
+    // https://stackoverflow.com/questions/39280438/fetch-missing-boundary-in-multipart-form-data-post
+    if (requestContentType !== 'multipart/form-data') {
+      headers['Content-Type'] = requestContentType ?? 'application/json';
+    }
+
     const signal = AbortSignal.timeout(this.apiConfig.timeout);
 
+    const encodedBody =
+      requestContentType === 'multipart/form-data'
+        ? new FormData()
+        : JSON.stringify(body);
+    if (requestContentType === 'multipart/form-data') {
+      Object.keys(body).forEach((key) => {
+        (encodedBody as FormData).append(key, body[key]);
+      });
+    }
+
     try {
       const response = await fetch(`${this.apiConfig.baseUrl}${url}`, {
         signal,
         method,
-        body: JSON.stringify(body),
+        body: encodedBody,
         headers,
         dispatcher: this.dispatcher,
       });
diff --git a/src/StreamCall.ts b/src/StreamCall.ts
index d7b16f6..f66c035 100644
--- a/src/StreamCall.ts
+++ b/src/StreamCall.ts
@@ -1,4 +1,4 @@
-import { QueryCallMembersRequest } from './gen/models';
+import { GetOrCreateCallRequest, QueryCallMembersRequest } from './gen/models';
 import { CallApi } from './gen/video/CallApi';
 import { OmitTypeId } from './types';
 
@@ -7,7 +7,7 @@ export class StreamCall extends CallApi {
     return `${this.type}:${this.id}`;
   }
 
-  create = this.getOrCreate;
+  create = (request?: GetOrCreateCallRequest) => this.getOrCreate(request);
 
   queryMembers = (request?: OmitTypeId<QueryCallMembersRequest>) => {
     return this.videoApi.queryCallMembers({
diff --git a/src/StreamClient.ts b/src/StreamClient.ts
index 8600ebb..b194503 100644
--- a/src/StreamClient.ts
+++ b/src/StreamClient.ts
@@ -4,8 +4,16 @@ import { StreamVideoClient } from './StreamVideoClient';
 import crypto from 'crypto';
 import { StreamChatClient } from './StreamChatClient';
 import { CallTokenPayload, UserTokenPayload } from './types';
-import { QueryBannedUsersPayload, UserRequest } from './gen/models';
+import {
+  FileUploadRequest,
+  ImageUploadRequest,
+  QueryBannedUsersPayload,
+  UserRequest,
+} from './gen/models';
 import { StreamModerationClient } from './StreamModerationClient';
+import { ApiClient } from './ApiClient';
+import { StreamFeedsClient } from './StreamFeedsClient';
+import { File } from 'buffer';
 
 export interface StreamClientOptions {
   timeout?: number;
@@ -19,6 +27,7 @@ export class StreamClient extends CommonApi {
   public readonly video: StreamVideoClient;
   public readonly chat: StreamChatClient;
   public readonly moderation: StreamModerationClient;
+  public readonly feeds: StreamFeedsClient;
   public readonly options: StreamClientOptions = {};
 
   private static readonly DEFAULT_TIMEOUT = 3000;
@@ -38,36 +47,40 @@ export class StreamClient extends CommonApi {
     const timeout = config?.timeout ?? StreamClient.DEFAULT_TIMEOUT;
     const chatBaseUrl = config?.basePath ?? 'https://chat.stream-io-api.com';
     const videoBaseUrl = config?.basePath ?? 'https://video.stream-io-api.com';
-    super({
+    const feedsBaseUrl = config?.basePath ?? 'https://video.stream-io-api.com';
+    const chatApiClient = new ApiClient({
       apiKey,
       token,
-      timeout,
       baseUrl: chatBaseUrl,
+      timeout,
       agent: config?.agent as RequestInit['dispatcher'],
     });
 
-    this.video = new StreamVideoClient({
-      streamClient: this,
+    const videoApiClient = new ApiClient({
       apiKey,
       token,
-      timeout,
       baseUrl: videoBaseUrl,
-      agent: config?.agent as RequestInit['dispatcher'],
-    });
-    this.chat = new StreamChatClient({
-      apiKey,
-      token,
       timeout,
-      baseUrl: chatBaseUrl,
       agent: config?.agent as RequestInit['dispatcher'],
     });
-    this.moderation = new StreamModerationClient({
+
+    const feedsApiClient = new ApiClient({
       apiKey,
       token,
+      baseUrl: feedsBaseUrl,
       timeout,
-      baseUrl: chatBaseUrl,
       agent: config?.agent as RequestInit['dispatcher'],
     });
+
+    super(chatApiClient);
+
+    this.video = new StreamVideoClient({
+      streamClient: this,
+      apiClient: videoApiClient,
+    });
+    this.chat = new StreamChatClient(this.apiClient);
+    this.moderation = new StreamModerationClient(chatApiClient);
+    this.feeds = new StreamFeedsClient(feedsApiClient);
   }
 
   upsertUsers = (users: UserRequest[]) => {
@@ -84,6 +97,30 @@ export class StreamClient extends CommonApi {
     return this.chat.queryBannedUsers(request);
   };
 
+  // @ts-expect-error API spec says file should be a string
+  uploadFile = (request: Omit<FileUploadRequest, 'file'> & { file: File }) => {
+    return super.uploadFile({
+      // @ts-expect-error API spec says file should be a string
+      file: request.file,
+      // @ts-expect-error form data will only work if this is a string
+      user: JSON.stringify(request.user),
+    });
+  };
+
+  // @ts-expect-error API spec says file should be a string
+  uploadImage = (
+    request: Omit<ImageUploadRequest, 'file'> & { file: File },
+  ) => {
+    return super.uploadImage({
+      // @ts-expect-error API spec says file should be a string
+      file: request.file,
+      // @ts-expect-error form data will only work if this is a string
+      user: JSON.stringify(request.user),
+      // @ts-expect-error form data will only work if this is a string
+      upload_sizes: JSON.stringify(request.upload_sizes),
+    });
+  };
+
   /**
    *
    * @param payload
diff --git a/src/StreamFeed.ts b/src/StreamFeed.ts
new file mode 100644
index 0000000..63c581f
--- /dev/null
+++ b/src/StreamFeed.ts
@@ -0,0 +1,7 @@
+import { FeedApi } from './gen/feeds/FeedApi';
+
+export class StreamFeed extends FeedApi {
+  get fid() {
+    return `${this.group}:${this.id}`;
+  }
+}
diff --git a/src/StreamFeedsClient.ts b/src/StreamFeedsClient.ts
new file mode 100644
index 0000000..d138d91
--- /dev/null
+++ b/src/StreamFeedsClient.ts
@@ -0,0 +1,8 @@
+import { FeedsApi } from './gen/feeds/FeedsApi';
+import { StreamFeed } from './StreamFeed';
+
+export class StreamFeedsClient extends FeedsApi {
+  feed = (group: string, id: string) => {
+    return new StreamFeed(this, group, id);
+  };
+}
diff --git a/src/StreamVideoClient.ts b/src/StreamVideoClient.ts
index 900bb72..ac1e6c4 100644
--- a/src/StreamVideoClient.ts
+++ b/src/StreamVideoClient.ts
@@ -1,7 +1,7 @@
+import { ApiClient } from './ApiClient';
 import { VideoApi } from './gen/video/VideoApi';
 import { StreamCall } from './StreamCall';
 import type { StreamClient } from './StreamClient';
-import type { ApiConfig } from './types';
 // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
 /** @ts-ignore Optional dependency */
 import type {
@@ -15,9 +15,12 @@ export class StreamVideoClient extends VideoApi {
 
   constructor({
     streamClient,
-    ...apiConfig
-  }: ApiConfig & { streamClient: StreamClient }) {
-    super(apiConfig);
+    apiClient,
+  }: {
+    streamClient: StreamClient;
+    apiClient: ApiClient;
+  }) {
+    super(apiClient);
     this.streamClient = streamClient;
   }
 
@@ -54,9 +57,9 @@ export class StreamVideoClient extends VideoApi {
     });
 
     const realtimeClient = doCreateRealtimeClient({
-      baseUrl: this.apiConfig.baseUrl,
+      baseUrl: this.streamClient.apiClient.apiConfig.baseUrl,
       call: options.call,
-      streamApiKey: this.apiConfig.apiKey,
+      streamApiKey: this.streamClient.apiClient.apiConfig.apiKey,
       streamUserToken: token,
       openAiApiKey: options.openAiApiKey,
       model: options.model,
diff --git a/src/gen-imports.ts b/src/gen-imports.ts
new file mode 100644
index 0000000..a107901
--- /dev/null
+++ b/src/gen-imports.ts
@@ -0,0 +1,5 @@
+export * from './ApiClient';
+export * from './gen/chat/ChatApi';
+export * from './gen/video/VideoApi';
+export * from './types';
+export * from './gen/feeds/FeedsApi';
diff --git a/src/gen/chat/ChannelApi.ts b/src/gen/chat/ChannelApi.ts
index 763d59e..c3ad843 100644
--- a/src/gen/chat/ChannelApi.ts
+++ b/src/gen/chat/ChannelApi.ts
@@ -1,5 +1,4 @@
-import { ChatApi } from './ChatApi';
-import { StreamResponse } from '../../types';
+import { StreamResponse, ChatApi } from '../../gen-imports';
 import {
   ChannelGetOrCreateRequest,
   ChannelStateResponse,
@@ -36,281 +35,292 @@ export class ChannelApi {
   constructor(
     protected chatApi: ChatApi,
     public readonly type: string,
-    public id?: string,
+    public id: string | undefined,
   ) {}
 
-  delete = (request?: {
+  delete(request?: {
     hard_delete?: boolean;
-  }): Promise<StreamResponse<DeleteChannelResponse>> => {
+  }): Promise<StreamResponse<DeleteChannelResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.deleteChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  updateChannelPartial = (
+  updateChannelPartial(
     request?: UpdateChannelPartialRequest,
-  ): Promise<StreamResponse<UpdateChannelPartialResponse>> => {
+  ): Promise<StreamResponse<UpdateChannelPartialResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.updateChannelPartial({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  update = (
+  update(
     request?: UpdateChannelRequest,
-  ): Promise<StreamResponse<UpdateChannelResponse>> => {
+  ): Promise<StreamResponse<UpdateChannelResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.updateChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  deleteDraft = (request?: {
+  deleteDraft(request?: {
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.deleteDraft({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  getDraft = (request?: {
+  getDraft(request?: {
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<GetDraftResponse>> => {
+  }): Promise<StreamResponse<GetDraftResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.getDraft({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  sendEvent = (
-    request: SendEventRequest,
-  ): Promise<StreamResponse<EventResponse>> => {
+  sendEvent(request: SendEventRequest): Promise<StreamResponse<EventResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.sendEvent({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  deleteFile = (request?: {
-    url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  deleteFile(request?: { url?: string }): Promise<StreamResponse<Response>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.deleteFile({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  uploadFile = (
+  uploadFile(
     request?: FileUploadRequest,
-  ): Promise<StreamResponse<FileUploadResponse>> => {
+  ): Promise<StreamResponse<FileUploadResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.uploadFile({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  hide = (
+  hide(
     request?: HideChannelRequest,
-  ): Promise<StreamResponse<HideChannelResponse>> => {
+  ): Promise<StreamResponse<HideChannelResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.hideChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  deleteImage = (request?: {
-    url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  deleteImage(request?: { url?: string }): Promise<StreamResponse<Response>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.deleteImage({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  uploadImage = (
+  uploadImage(
     request?: ImageUploadRequest,
-  ): Promise<StreamResponse<ImageUploadResponse>> => {
+  ): Promise<StreamResponse<ImageUploadResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.uploadImage({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  updateMemberPartial = (
+  updateMemberPartial(
     request?: UpdateMemberPartialRequest & { user_id?: string },
-  ): Promise<StreamResponse<UpdateMemberPartialResponse>> => {
+  ): Promise<StreamResponse<UpdateMemberPartialResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.updateMemberPartial({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  sendMessage = (
+  sendMessage(
     request: SendMessageRequest,
-  ): Promise<StreamResponse<SendMessageResponse>> => {
+  ): Promise<StreamResponse<SendMessageResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.sendMessage({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  getManyMessages = (request: {
+  getManyMessages(request: {
     ids: string[];
-  }): Promise<StreamResponse<GetManyMessagesResponse>> => {
+  }): Promise<StreamResponse<GetManyMessagesResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.getManyMessages({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  getOrCreate = (
+  getOrCreate(
     request?: ChannelGetOrCreateRequest,
-  ): Promise<StreamResponse<ChannelStateResponse>> => {
+  ): Promise<StreamResponse<ChannelStateResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.getOrCreateChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  markRead = (
+  markRead(
     request?: MarkReadRequest,
-  ): Promise<StreamResponse<MarkReadResponse>> => {
+  ): Promise<StreamResponse<MarkReadResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.markRead({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  show = (
+  show(
     request?: ShowChannelRequest,
-  ): Promise<StreamResponse<ShowChannelResponse>> => {
+  ): Promise<StreamResponse<ShowChannelResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.showChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  truncate = (
+  truncate(
     request?: TruncateChannelRequest,
-  ): Promise<StreamResponse<TruncateChannelResponse>> => {
+  ): Promise<StreamResponse<TruncateChannelResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.truncateChannel({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  markUnread = (
-    request?: MarkUnreadRequest,
-  ): Promise<StreamResponse<Response>> => {
+  markUnread(request?: MarkUnreadRequest): Promise<StreamResponse<Response>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.markUnread({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 }
diff --git a/src/gen/chat/ChatApi.ts b/src/gen/chat/ChatApi.ts
index 3a85d25..ae09857 100644
--- a/src/gen/chat/ChatApi.ts
+++ b/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,
@@ -895,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,
@@ -921,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,
     };
@@ -980,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,
@@ -1009,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,
     };
@@ -1065,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,
@@ -1087,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,
@@ -1108,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,
@@ -1147,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,
@@ -1169,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,
     };
@@ -1189,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,
     };
@@ -1213,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,
     };
@@ -1236,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,
     };
@@ -1257,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,
     };
@@ -1303,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',
@@ -1311,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,
     };
@@ -1331,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',
@@ -1343,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,
@@ -1358,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,
     };
@@ -1383,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',
@@ -1391,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,
     };
@@ -1408,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,
     };
@@ -1433,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',
@@ -1441,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,
@@ -1461,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,
     };
@@ -1489,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,
@@ -1499,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,
     };
@@ -1512,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',
@@ -1524,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,
     };
@@ -1538,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',
@@ -1546,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,
     };
@@ -1565,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',
@@ -1573,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;
@@ -1595,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,
@@ -1615,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,
@@ -1625,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,
@@ -1653,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',
@@ -1661,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,
@@ -1678,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,
@@ -2033,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,
@@ -2071,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,
@@ -2110,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,
@@ -2136,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,
     };
@@ -2167,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,
@@ -2199,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,
     };
@@ -2215,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',
@@ -2223,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,
@@ -2246,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,
@@ -2270,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,
     };
@@ -2295,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',
@@ -2303,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,
     };
@@ -2348,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 };
-  };
+  }
 }
diff --git a/src/gen/common/CommonApi.ts b/src/gen/common/CommonApi.ts
index cc5b505..306383f 100644
--- a/src/gen/common/CommonApi.ts
+++ b/src/gen/common/CommonApi.ts
@@ -1,5 +1,4 @@
-import { BaseApi } from '../../BaseApi';
-import { StreamResponse } from '../../types';
+import { ApiClient, StreamResponse } from '../../gen-imports';
 import {
   BlockUsersRequest,
   BlockUsersResponse,
@@ -21,6 +20,8 @@ import {
   CreateImportResponse,
   CreateImportURLRequest,
   CreateImportURLResponse,
+  CreatePollOptionRequest,
+  CreatePollRequest,
   CreateRoleRequest,
   CreateRoleResponse,
   DeactivateUserRequest,
@@ -52,6 +53,12 @@ import {
   ListPermissionsResponse,
   ListPushProvidersResponse,
   ListRolesResponse,
+  PollOptionResponse,
+  PollResponse,
+  PollVotesResponse,
+  QueryPollVotesRequest,
+  QueryPollsRequest,
+  QueryPollsResponse,
   QueryUsersPayload,
   QueryUsersResponse,
   ReactivateUserRequest,
@@ -70,28 +77,33 @@ import {
   UpdateExternalStorageRequest,
   UpdateExternalStorageResponse,
   UpdateLiveLocationRequest,
+  UpdatePollOptionRequest,
+  UpdatePollPartialRequest,
+  UpdatePollRequest,
   UpdateUsersPartialRequest,
   UpdateUsersRequest,
   UpdateUsersResponse,
   UpsertPushProviderRequest,
   UpsertPushProviderResponse,
 } from '../models';
-import { decoders } from '../model-decoders';
+import { decoders } from '../model-decoders/decoders';
 
-export class CommonApi extends BaseApi {
-  getApp = async (): Promise<StreamResponse<GetApplicationResponse>> => {
-    const response = await this.sendRequest<
+export class CommonApi {
+  constructor(public readonly apiClient: ApiClient) {}
+
+  async getApp(): Promise<StreamResponse<GetApplicationResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetApplicationResponse>
     >('GET', '/api/v2/app', undefined, undefined);
 
     decoders.GetApplicationResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateApp = async (
+  async updateApp(
     request?: UpdateAppRequest,
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const body = {
       async_url_enrich_enabled: request?.async_url_enrich_enabled,
       auto_translation_enabled: request?.auto_translation_enabled,
@@ -141,38 +153,39 @@ export class CommonApi extends BaseApi {
       xiaomi_config: request?.xiaomi_config,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'PATCH',
       '/api/v2/app',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listBlockLists = async (request?: {
+  async listBlockLists(request?: {
     team?: string;
-  }): Promise<StreamResponse<ListBlockListResponse>> => {
+  }): Promise<StreamResponse<ListBlockListResponse>> {
     const queryParams = {
       team: request?.team,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListBlockListResponse>
     >('GET', '/api/v2/blocklists', undefined, queryParams);
 
     decoders.ListBlockListResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createBlockList = async (
+  async createBlockList(
     request: CreateBlockListRequest,
-  ): Promise<StreamResponse<CreateBlockListResponse>> => {
+  ): Promise<StreamResponse<CreateBlockListResponse>> {
     const body = {
       name: request?.name,
       words: request?.words,
@@ -180,19 +193,26 @@ export class CommonApi extends BaseApi {
       type: request?.type,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateBlockListResponse>
-    >('POST', '/api/v2/blocklists', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/blocklists',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateBlockListResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteBlockList = async (request: {
+  async deleteBlockList(request: {
     name: string;
     team?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       team: request?.team,
     };
@@ -200,7 +220,7 @@ export class CommonApi extends BaseApi {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/blocklists/{name}',
       pathParams,
@@ -210,12 +230,12 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getBlockList = async (request: {
+  async getBlockList(request: {
     name: string;
     team?: string;
-  }): Promise<StreamResponse<GetBlockListResponse>> => {
+  }): Promise<StreamResponse<GetBlockListResponse>> {
     const queryParams = {
       team: request?.team,
     };
@@ -223,18 +243,18 @@ export class CommonApi extends BaseApi {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetBlockListResponse>
     >('GET', '/api/v2/blocklists/{name}', pathParams, queryParams);
 
     decoders.GetBlockListResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateBlockList = async (
+  async updateBlockList(
     request: UpdateBlockListRequest & { name: string },
-  ): Promise<StreamResponse<UpdateBlockListResponse>> => {
+  ): Promise<StreamResponse<UpdateBlockListResponse>> {
     const pathParams = {
       name: request?.name,
     };
@@ -243,18 +263,25 @@ export class CommonApi extends BaseApi {
       words: request?.words,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateBlockListResponse>
-    >('PUT', '/api/v2/blocklists/{name}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/blocklists/{name}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateBlockListResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  checkPush = async (
+  async checkPush(
     request?: CheckPushRequest,
-  ): Promise<StreamResponse<CheckPushResponse>> => {
+  ): Promise<StreamResponse<CheckPushResponse>> {
     const body = {
       apn_template: request?.apn_template,
       event_type: request?.event_type,
@@ -268,73 +295,82 @@ export class CommonApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<CheckPushResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CheckPushResponse>
+    >(
       'POST',
       '/api/v2/check_push',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CheckPushResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  checkSNS = async (
+  async checkSNS(
     request?: CheckSNSRequest,
-  ): Promise<StreamResponse<CheckSNSResponse>> => {
+  ): Promise<StreamResponse<CheckSNSResponse>> {
     const body = {
       sns_key: request?.sns_key,
       sns_secret: request?.sns_secret,
       sns_topic_arn: request?.sns_topic_arn,
     };
 
-    const response = await this.sendRequest<StreamResponse<CheckSNSResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CheckSNSResponse>
+    >(
       'POST',
       '/api/v2/check_sns',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CheckSNSResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  checkSQS = async (
+  async checkSQS(
     request?: CheckSQSRequest,
-  ): Promise<StreamResponse<CheckSQSResponse>> => {
+  ): Promise<StreamResponse<CheckSQSResponse>> {
     const body = {
       sqs_key: request?.sqs_key,
       sqs_secret: request?.sqs_secret,
       sqs_url: request?.sqs_url,
     };
 
-    const response = await this.sendRequest<StreamResponse<CheckSQSResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CheckSQSResponse>
+    >(
       'POST',
       '/api/v2/check_sqs',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CheckSQSResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteDevice = async (request: {
+  async deleteDevice(request: {
     id: string;
     user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       id: request?.id,
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/devices',
       undefined,
@@ -344,27 +380,27 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listDevices = async (request?: {
+  async listDevices(request?: {
     user_id?: string;
-  }): Promise<StreamResponse<ListDevicesResponse>> => {
+  }): Promise<StreamResponse<ListDevicesResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListDevicesResponse>
     >('GET', '/api/v2/devices', undefined, queryParams);
 
     decoders.ListDevicesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createDevice = async (
+  async createDevice(
     request: CreateDeviceRequest,
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const body = {
       id: request?.id,
       push_provider: request?.push_provider,
@@ -374,50 +410,58 @@ export class CommonApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'POST',
       '/api/v2/devices',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  exportUsers = async (
+  async exportUsers(
     request: ExportUsersRequest,
-  ): Promise<StreamResponse<ExportUsersResponse>> => {
+  ): Promise<StreamResponse<ExportUsersResponse>> {
     const body = {
       user_ids: request?.user_ids,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ExportUsersResponse>
-    >('POST', '/api/v2/export/users', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/export/users',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.ExportUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listExternalStorage = async (): Promise<
+  async listExternalStorage(): Promise<
     StreamResponse<ListExternalStorageResponse>
-  > => {
-    const response = await this.sendRequest<
+  > {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListExternalStorageResponse>
     >('GET', '/api/v2/external_storage', undefined, undefined);
 
     decoders.ListExternalStorageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createExternalStorage = async (
+  async createExternalStorage(
     request: CreateExternalStorageRequest,
-  ): Promise<StreamResponse<CreateExternalStorageResponse>> => {
+  ): Promise<StreamResponse<CreateExternalStorageResponse>> {
     const body = {
       bucket: request?.bucket,
       name: request?.name,
@@ -428,34 +472,41 @@ export class CommonApi extends BaseApi {
       azure_blob: request?.azure_blob,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateExternalStorageResponse>
-    >('POST', '/api/v2/external_storage', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/external_storage',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateExternalStorageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteExternalStorage = async (request: {
+  async deleteExternalStorage(request: {
     name: string;
-  }): Promise<StreamResponse<DeleteExternalStorageResponse>> => {
+  }): Promise<StreamResponse<DeleteExternalStorageResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteExternalStorageResponse>
     >('DELETE', '/api/v2/external_storage/{name}', pathParams, undefined);
 
     decoders.DeleteExternalStorageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateExternalStorage = async (
+  async updateExternalStorage(
     request: UpdateExternalStorageRequest & { name: string },
-  ): Promise<StreamResponse<UpdateExternalStorageResponse>> => {
+  ): Promise<StreamResponse<UpdateExternalStorageResponse>> {
     const pathParams = {
       name: request?.name,
     };
@@ -468,194 +519,516 @@ export class CommonApi extends BaseApi {
       azure_blob: request?.azure_blob,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateExternalStorageResponse>
-    >('PUT', '/api/v2/external_storage/{name}', pathParams, undefined, body);
+    >(
+      'PUT',
+      '/api/v2/external_storage/{name}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpdateExternalStorageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  checkExternalStorage = async (request: {
+  async checkExternalStorage(request: {
     name: string;
-  }): Promise<StreamResponse<CheckExternalStorageResponse>> => {
+  }): Promise<StreamResponse<CheckExternalStorageResponse>> {
     const pathParams = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CheckExternalStorageResponse>
     >('GET', '/api/v2/external_storage/{name}/check', pathParams, undefined);
 
     decoders.CheckExternalStorageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createGuest = async (
+  async createGuest(
     request: CreateGuestRequest,
-  ): Promise<StreamResponse<CreateGuestResponse>> => {
+  ): Promise<StreamResponse<CreateGuestResponse>> {
     const body = {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateGuestResponse>
-    >('POST', '/api/v2/guest', undefined, undefined, body);
+    >('POST', '/api/v2/guest', undefined, undefined, body, 'application/json');
 
     decoders.CreateGuestResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createImportURL = async (
+  async createImportURL(
     request?: CreateImportURLRequest,
-  ): Promise<StreamResponse<CreateImportURLResponse>> => {
+  ): Promise<StreamResponse<CreateImportURLResponse>> {
     const body = {
       filename: request?.filename,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateImportURLResponse>
-    >('POST', '/api/v2/import_urls', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/import_urls',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateImportURLResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listImports = async (): Promise<StreamResponse<ListImportsResponse>> => {
-    const response = await this.sendRequest<
+  async listImports(): Promise<StreamResponse<ListImportsResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListImportsResponse>
     >('GET', '/api/v2/imports', undefined, undefined);
 
     decoders.ListImportsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createImport = async (
+  async createImport(
     request: CreateImportRequest,
-  ): Promise<StreamResponse<CreateImportResponse>> => {
+  ): Promise<StreamResponse<CreateImportResponse>> {
     const body = {
       mode: request?.mode,
       path: request?.path,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CreateImportResponse>
-    >('POST', '/api/v2/imports', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/imports',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CreateImportResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getImport = async (request: {
+  async getImport(request: {
     id: string;
-  }): Promise<StreamResponse<GetImportResponse>> => {
+  }): Promise<StreamResponse<GetImportResponse>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetImportResponse>>(
-      'GET',
-      '/api/v2/imports/{id}',
-      pathParams,
-      undefined,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetImportResponse>
+    >('GET', '/api/v2/imports/{id}', pathParams, undefined);
 
     decoders.GetImportResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getOG = async (request: {
+  async getOG(request: {
     url: string;
-  }): Promise<StreamResponse<GetOGResponse>> => {
+  }): Promise<StreamResponse<GetOGResponse>> {
     const queryParams = {
       url: request?.url,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetOGResponse>>(
-      'GET',
-      '/api/v2/og',
-      undefined,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetOGResponse>
+    >('GET', '/api/v2/og', undefined, queryParams);
 
     decoders.GetOGResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listPermissions = async (): Promise<
-    StreamResponse<ListPermissionsResponse>
-  > => {
-    const response = await this.sendRequest<
+  async listPermissions(): Promise<StreamResponse<ListPermissionsResponse>> {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListPermissionsResponse>
     >('GET', '/api/v2/permissions', undefined, undefined);
 
     decoders.ListPermissionsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getPermission = async (request: {
+  async getPermission(request: {
     id: string;
-  }): Promise<StreamResponse<GetCustomPermissionResponse>> => {
+  }): Promise<StreamResponse<GetCustomPermissionResponse>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetCustomPermissionResponse>
     >('GET', '/api/v2/permissions/{id}', pathParams, undefined);
 
     decoders.GetCustomPermissionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
+
+  async createPoll(
+    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.apiClient.sendRequest<
+      StreamResponse<PollResponse>
+    >('POST', '/api/v2/polls', undefined, undefined, body, 'application/json');
+
+    decoders.PollResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updatePoll(
+    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.apiClient.sendRequest<
+      StreamResponse<PollResponse>
+    >('PUT', '/api/v2/polls', undefined, undefined, body, 'application/json');
+
+    decoders.PollResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryPolls(
+    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.apiClient.sendRequest<
+      StreamResponse<QueryPollsResponse>
+    >(
+      'POST',
+      '/api/v2/polls/query',
+      undefined,
+      queryParams,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryPollsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deletePoll(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.apiClient.sendRequest<StreamResponse<Response>>(
+      'DELETE',
+      '/api/v2/polls/{poll_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.Response?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getPoll(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.apiClient.sendRequest<
+      StreamResponse<PollResponse>
+    >('GET', '/api/v2/polls/{poll_id}', pathParams, queryParams);
+
+    decoders.PollResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updatePollPartial(
+    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.apiClient.sendRequest<
+      StreamResponse<PollResponse>
+    >(
+      'PATCH',
+      '/api/v2/polls/{poll_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.PollResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createPollOption(
+    request: CreatePollOptionRequest & { poll_id: string },
+  ): Promise<StreamResponse<PollOptionResponse>> {
+    const pathParams = {
+      poll_id: request?.poll_id,
+    };
+    const body = {
+      text: request?.text,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PollOptionResponse>
+    >(
+      'POST',
+      '/api/v2/polls/{poll_id}/options',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.PollOptionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updatePollOption(
+    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.apiClient.sendRequest<
+      StreamResponse<PollOptionResponse>
+    >(
+      'PUT',
+      '/api/v2/polls/{poll_id}/options',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.PollOptionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deletePollOption(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.apiClient.sendRequest<StreamResponse<Response>>(
+      'DELETE',
+      '/api/v2/polls/{poll_id}/options/{option_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.Response?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getPollOption(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.apiClient.sendRequest<
+      StreamResponse<PollOptionResponse>
+    >(
+      'GET',
+      '/api/v2/polls/{poll_id}/options/{option_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.PollOptionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryPollVotes(
+    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.apiClient.sendRequest<
+      StreamResponse<PollVotesResponse>
+    >(
+      'POST',
+      '/api/v2/polls/{poll_id}/votes',
+      pathParams,
+      queryParams,
+      body,
+      'application/json',
+    );
+
+    decoders.PollVotesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
 
-  listPushProviders = async (): Promise<
+  async listPushProviders(): Promise<
     StreamResponse<ListPushProvidersResponse>
-  > => {
-    const response = await this.sendRequest<
+  > {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ListPushProvidersResponse>
     >('GET', '/api/v2/push_providers', undefined, undefined);
 
     decoders.ListPushProvidersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  upsertPushProvider = async (
+  async upsertPushProvider(
     request?: UpsertPushProviderRequest,
-  ): Promise<StreamResponse<UpsertPushProviderResponse>> => {
+  ): Promise<StreamResponse<UpsertPushProviderResponse>> {
     const body = {
       push_provider: request?.push_provider,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpsertPushProviderResponse>
-    >('POST', '/api/v2/push_providers', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/push_providers',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpsertPushProviderResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deletePushProvider = async (request: {
+  async deletePushProvider(request: {
     type: string;
     name: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const pathParams = {
       type: request?.type,
       name: request?.name,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/push_providers/{type}/{name}',
       pathParams,
@@ -665,15 +1038,15 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getRateLimits = async (request?: {
+  async getRateLimits(request?: {
     server_side?: boolean;
     android?: boolean;
     ios?: boolean;
     web?: boolean;
     endpoints?: string;
-  }): Promise<StreamResponse<GetRateLimitsResponse>> => {
+  }): Promise<StreamResponse<GetRateLimitsResponse>> {
     const queryParams = {
       server_side: request?.server_side,
       android: request?.android,
@@ -682,56 +1055,49 @@ export class CommonApi extends BaseApi {
       endpoints: request?.endpoints,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetRateLimitsResponse>
     >('GET', '/api/v2/rate_limits', undefined, queryParams);
 
     decoders.GetRateLimitsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  listRoles = async (): Promise<StreamResponse<ListRolesResponse>> => {
-    const response = await this.sendRequest<StreamResponse<ListRolesResponse>>(
-      'GET',
-      '/api/v2/roles',
-      undefined,
-      undefined,
-    );
+  async listRoles(): Promise<StreamResponse<ListRolesResponse>> {
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ListRolesResponse>
+    >('GET', '/api/v2/roles', undefined, undefined);
 
     decoders.ListRolesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  createRole = async (
+  async createRole(
     request: CreateRoleRequest,
-  ): Promise<StreamResponse<CreateRoleResponse>> => {
+  ): Promise<StreamResponse<CreateRoleResponse>> {
     const body = {
       name: request?.name,
     };
 
-    const response = await this.sendRequest<StreamResponse<CreateRoleResponse>>(
-      'POST',
-      '/api/v2/roles',
-      undefined,
-      undefined,
-      body,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateRoleResponse>
+    >('POST', '/api/v2/roles', undefined, undefined, body, 'application/json');
 
     decoders.CreateRoleResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteRole = async (request: {
+  async deleteRole(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/roles/{name}',
       pathParams,
@@ -741,35 +1107,32 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getTask = async (request: {
+  async getTask(request: {
     id: string;
-  }): Promise<StreamResponse<GetTaskResponse>> => {
+  }): Promise<StreamResponse<GetTaskResponse>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetTaskResponse>>(
-      'GET',
-      '/api/v2/tasks/{id}',
-      pathParams,
-      undefined,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetTaskResponse>
+    >('GET', '/api/v2/tasks/{id}', pathParams, undefined);
 
     decoders.GetTaskResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteFile = async (request?: {
+  async deleteFile(request?: {
     url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       url: request?.url,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/uploads/file',
       undefined,
@@ -779,37 +1142,40 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  uploadFile = async (
+  async uploadFile(
     request?: FileUploadRequest,
-  ): Promise<StreamResponse<FileUploadResponse>> => {
+  ): Promise<StreamResponse<FileUploadResponse>> {
     const body = {
       file: request?.file,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<FileUploadResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FileUploadResponse>
+    >(
       'POST',
       '/api/v2/uploads/file',
       undefined,
       undefined,
       body,
+      'multipart/form-data',
     );
 
     decoders.FileUploadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteImage = async (request?: {
+  async deleteImage(request?: {
     url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): Promise<StreamResponse<Response>> {
     const queryParams = {
       url: request?.url,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'DELETE',
       '/api/v2/uploads/image',
       undefined,
@@ -819,118 +1185,125 @@ export class CommonApi extends BaseApi {
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  uploadImage = async (
+  async uploadImage(
     request?: ImageUploadRequest,
-  ): Promise<StreamResponse<ImageUploadResponse>> => {
+  ): Promise<StreamResponse<ImageUploadResponse>> {
     const body = {
       file: request?.file,
       upload_sizes: request?.upload_sizes,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ImageUploadResponse>
-    >('POST', '/api/v2/uploads/image', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/uploads/image',
+      undefined,
+      undefined,
+      body,
+      'multipart/form-data',
+    );
 
     decoders.ImageUploadResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryUsers = async (request?: {
+  async queryUsers(request?: {
     payload?: QueryUsersPayload;
-  }): Promise<StreamResponse<QueryUsersResponse>> => {
+  }): Promise<StreamResponse<QueryUsersResponse>> {
     const queryParams = {
       payload: request?.payload,
     };
 
-    const response = await this.sendRequest<StreamResponse<QueryUsersResponse>>(
-      'GET',
-      '/api/v2/users',
-      undefined,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryUsersResponse>
+    >('GET', '/api/v2/users', undefined, queryParams);
 
     decoders.QueryUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateUsersPartial = async (
+  async updateUsersPartial(
     request: UpdateUsersPartialRequest,
-  ): Promise<StreamResponse<UpdateUsersResponse>> => {
+  ): Promise<StreamResponse<UpdateUsersResponse>> {
     const body = {
       users: request?.users,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateUsersResponse>
-    >('PATCH', '/api/v2/users', undefined, undefined, body);
+    >('PATCH', '/api/v2/users', undefined, undefined, body, 'application/json');
 
     decoders.UpdateUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateUsers = async (
+  async updateUsers(
     request: UpdateUsersRequest,
-  ): Promise<StreamResponse<UpdateUsersResponse>> => {
+  ): Promise<StreamResponse<UpdateUsersResponse>> {
     const body = {
       users: request?.users,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpdateUsersResponse>
-    >('POST', '/api/v2/users', undefined, undefined, body);
+    >('POST', '/api/v2/users', undefined, undefined, body, 'application/json');
 
     decoders.UpdateUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getBlockedUsers = async (request?: {
+  async getBlockedUsers(request?: {
     user_id?: string;
-  }): Promise<StreamResponse<GetBlockedUsersResponse>> => {
+  }): Promise<StreamResponse<GetBlockedUsersResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetBlockedUsersResponse>
     >('GET', '/api/v2/users/block', undefined, queryParams);
 
     decoders.GetBlockedUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  blockUsers = async (
+  async blockUsers(
     request: BlockUsersRequest,
-  ): Promise<StreamResponse<BlockUsersResponse>> => {
+  ): Promise<StreamResponse<BlockUsersResponse>> {
     const body = {
       blocked_user_id: request?.blocked_user_id,
       user_id: request?.user_id,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<BlockUsersResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<BlockUsersResponse>
+    >(
       'POST',
       '/api/v2/users/block',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.BlockUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deactivateUsers = async (
+  async deactivateUsers(
     request: DeactivateUsersRequest,
-  ): Promise<StreamResponse<DeactivateUsersResponse>> => {
+  ): Promise<StreamResponse<DeactivateUsersResponse>> {
     const body = {
       user_ids: request?.user_ids,
       created_by_id: request?.created_by_id,
@@ -938,18 +1311,25 @@ export class CommonApi extends BaseApi {
       mark_messages_deleted: request?.mark_messages_deleted,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeactivateUsersResponse>
-    >('POST', '/api/v2/users/deactivate', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/users/deactivate',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.DeactivateUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteUsers = async (
+  async deleteUsers(
     request: DeleteUsersRequest,
-  ): Promise<StreamResponse<DeleteUsersResponse>> => {
+  ): Promise<StreamResponse<DeleteUsersResponse>> {
     const body = {
       user_ids: request?.user_ids,
       calls: request?.calls,
@@ -960,34 +1340,41 @@ export class CommonApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteUsersResponse>
-    >('POST', '/api/v2/users/delete', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/users/delete',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.DeleteUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getUserLiveLocations = async (request?: {
+  async getUserLiveLocations(request?: {
     user_id?: string;
-  }): Promise<StreamResponse<SharedLocationsResponse>> => {
+  }): Promise<StreamResponse<SharedLocationsResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SharedLocationsResponse>
     >('GET', '/api/v2/users/live_locations', undefined, queryParams);
 
     decoders.SharedLocationsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  updateLiveLocation = async (
+  async updateLiveLocation(
     request: UpdateLiveLocationRequest & { user_id?: string },
-  ): Promise<StreamResponse<SharedLocationResponse>> => {
+  ): Promise<StreamResponse<SharedLocationResponse>> {
     const queryParams = {
       user_id: request?.user_id,
     };
@@ -999,18 +1386,25 @@ export class CommonApi extends BaseApi {
       longitude: request?.longitude,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SharedLocationResponse>
-    >('PUT', '/api/v2/users/live_locations', undefined, queryParams, body);
+    >(
+      'PUT',
+      '/api/v2/users/live_locations',
+      undefined,
+      queryParams,
+      body,
+      'application/json',
+    );
 
     decoders.SharedLocationResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  reactivateUsers = async (
+  async reactivateUsers(
     request: ReactivateUsersRequest,
-  ): Promise<StreamResponse<ReactivateUsersResponse>> => {
+  ): Promise<StreamResponse<ReactivateUsersResponse>> {
     const body = {
       user_ids: request?.user_ids,
       created_by_id: request?.created_by_id,
@@ -1018,56 +1412,71 @@ export class CommonApi extends BaseApi {
       restore_messages: request?.restore_messages,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ReactivateUsersResponse>
-    >('POST', '/api/v2/users/reactivate', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/users/reactivate',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.ReactivateUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  restoreUsers = async (
+  async restoreUsers(
     request: RestoreUsersRequest,
-  ): Promise<StreamResponse<Response>> => {
+  ): Promise<StreamResponse<Response>> {
     const body = {
       user_ids: request?.user_ids,
     };
 
-    const response = await this.sendRequest<StreamResponse<Response>>(
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
       'POST',
       '/api/v2/users/restore',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.Response?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unblockUsers = async (
+  async unblockUsers(
     request: UnblockUsersRequest,
-  ): Promise<StreamResponse<UnblockUsersResponse>> => {
+  ): Promise<StreamResponse<UnblockUsersResponse>> {
     const body = {
       blocked_user_id: request?.blocked_user_id,
       user_id: request?.user_id,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UnblockUsersResponse>
-    >('POST', '/api/v2/users/unblock', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/users/unblock',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UnblockUsersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deactivateUser = async (
+  async deactivateUser(
     request: DeactivateUserRequest & { user_id: string },
-  ): Promise<StreamResponse<DeactivateUserResponse>> => {
+  ): Promise<StreamResponse<DeactivateUserResponse>> {
     const pathParams = {
       user_id: request?.user_id,
     };
@@ -1076,7 +1485,7 @@ export class CommonApi extends BaseApi {
       mark_messages_deleted: request?.mark_messages_deleted,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeactivateUserResponse>
     >(
       'POST',
@@ -1084,35 +1493,33 @@ export class CommonApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.DeactivateUserResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  exportUser = async (request: {
+  async exportUser(request: {
     user_id: string;
-  }): Promise<StreamResponse<ExportUserResponse>> => {
+  }): Promise<StreamResponse<ExportUserResponse>> {
     const pathParams = {
       user_id: request?.user_id,
     };
 
-    const response = await this.sendRequest<StreamResponse<ExportUserResponse>>(
-      'GET',
-      '/api/v2/users/{user_id}/export',
-      pathParams,
-      undefined,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ExportUserResponse>
+    >('GET', '/api/v2/users/{user_id}/export', pathParams, undefined);
 
     decoders.ExportUserResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  reactivateUser = async (
+  async reactivateUser(
     request: ReactivateUserRequest & { user_id: string },
-  ): Promise<StreamResponse<ReactivateUserResponse>> => {
+  ): Promise<StreamResponse<ReactivateUserResponse>> {
     const pathParams = {
       user_id: request?.user_id,
     };
@@ -1122,7 +1529,7 @@ export class CommonApi extends BaseApi {
       restore_messages: request?.restore_messages,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<ReactivateUserResponse>
     >(
       'POST',
@@ -1130,10 +1537,11 @@ export class CommonApi extends BaseApi {
       pathParams,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.ReactivateUserResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 }
diff --git a/src/gen/feeds/FeedApi.ts b/src/gen/feeds/FeedApi.ts
new file mode 100644
index 0000000..bf82841
--- /dev/null
+++ b/src/gen/feeds/FeedApi.ts
@@ -0,0 +1,130 @@
+import { StreamResponse, FeedsApi } from '../../gen-imports';
+import {
+  AcceptFeedMemberInviteRequest,
+  AcceptFeedMemberInviteResponse,
+  DeleteFeedResponse,
+  GetOrCreateFeedRequest,
+  GetOrCreateFeedResponse,
+  MarkActivityRequest,
+  PinActivityRequest,
+  PinActivityResponse,
+  QueryFeedMembersRequest,
+  QueryFeedMembersResponse,
+  RejectFeedMemberInviteRequest,
+  RejectFeedMemberInviteResponse,
+  Response,
+  UnpinActivityResponse,
+  UpdateFeedMembersRequest,
+  UpdateFeedMembersResponse,
+  UpdateFeedRequest,
+  UpdateFeedResponse,
+} from '../models';
+
+export class FeedApi {
+  constructor(
+    protected feedsApi: FeedsApi,
+    public readonly group: string,
+    public readonly id: string,
+  ) {}
+
+  delete(request?: {
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteFeedResponse>> {
+    return this.feedsApi.deleteFeed({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  getOrCreate(
+    request?: GetOrCreateFeedRequest,
+  ): Promise<StreamResponse<GetOrCreateFeedResponse>> {
+    return this.feedsApi.getOrCreateFeed({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  update(
+    request?: UpdateFeedRequest,
+  ): Promise<StreamResponse<UpdateFeedResponse>> {
+    return this.feedsApi.updateFeed({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  markActivity(
+    request?: MarkActivityRequest,
+  ): Promise<StreamResponse<Response>> {
+    return this.feedsApi.markActivity({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  unpinActivity(request: {
+    activity_id: string;
+    user_id?: string;
+  }): Promise<StreamResponse<UnpinActivityResponse>> {
+    return this.feedsApi.unpinActivity({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  pinActivity(
+    request: PinActivityRequest & { activity_id: string },
+  ): Promise<StreamResponse<PinActivityResponse>> {
+    return this.feedsApi.pinActivity({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  updateFeedMembers(
+    request: UpdateFeedMembersRequest,
+  ): Promise<StreamResponse<UpdateFeedMembersResponse>> {
+    return this.feedsApi.updateFeedMembers({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  acceptFeedMemberInvite(
+    request?: AcceptFeedMemberInviteRequest,
+  ): Promise<StreamResponse<AcceptFeedMemberInviteResponse>> {
+    return this.feedsApi.acceptFeedMemberInvite({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  queryFeedMembers(
+    request?: QueryFeedMembersRequest,
+  ): Promise<StreamResponse<QueryFeedMembersResponse>> {
+    return this.feedsApi.queryFeedMembers({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
+  rejectFeedMemberInvite(
+    request?: RejectFeedMemberInviteRequest,
+  ): Promise<StreamResponse<RejectFeedMemberInviteResponse>> {
+    return this.feedsApi.rejectFeedMemberInvite({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+}
diff --git a/src/gen/feeds/FeedsApi.ts b/src/gen/feeds/FeedsApi.ts
new file mode 100644
index 0000000..40ac27b
--- /dev/null
+++ b/src/gen/feeds/FeedsApi.ts
@@ -0,0 +1,1801 @@
+import { ApiClient, StreamResponse } from '../../gen-imports';
+import {
+  AcceptFeedMemberInviteRequest,
+  AcceptFeedMemberInviteResponse,
+  AcceptFollowRequest,
+  AcceptFollowResponse,
+  AddActivityRequest,
+  AddActivityResponse,
+  AddBookmarkRequest,
+  AddBookmarkResponse,
+  AddCommentReactionRequest,
+  AddCommentReactionResponse,
+  AddCommentRequest,
+  AddCommentResponse,
+  AddCommentsBatchRequest,
+  AddCommentsBatchResponse,
+  AddReactionRequest,
+  AddReactionResponse,
+  CastPollVoteRequest,
+  CreateFeedGroupRequest,
+  CreateFeedGroupResponse,
+  CreateFeedViewRequest,
+  CreateFeedViewResponse,
+  CreateFeedsBatchRequest,
+  CreateFeedsBatchResponse,
+  DeleteActivitiesRequest,
+  DeleteActivitiesResponse,
+  DeleteActivityReactionResponse,
+  DeleteActivityResponse,
+  DeleteBookmarkFolderResponse,
+  DeleteBookmarkResponse,
+  DeleteCommentReactionResponse,
+  DeleteCommentResponse,
+  DeleteFeedGroupResponse,
+  DeleteFeedResponse,
+  DeleteFeedUserDataResponse,
+  DeleteFeedViewResponse,
+  ExportFeedUserDataResponse,
+  FollowBatchRequest,
+  FollowBatchResponse,
+  GetActivityResponse,
+  GetCommentRepliesResponse,
+  GetCommentResponse,
+  GetCommentsResponse,
+  GetFeedGroupResponse,
+  GetFeedViewResponse,
+  GetFollowSuggestionsResponse,
+  GetOrCreateFeedRequest,
+  GetOrCreateFeedResponse,
+  ListFeedGroupsResponse,
+  ListFeedViewsResponse,
+  MarkActivityRequest,
+  PinActivityRequest,
+  PinActivityResponse,
+  PollVoteResponse,
+  QueryActivitiesRequest,
+  QueryActivitiesResponse,
+  QueryActivityReactionsRequest,
+  QueryActivityReactionsResponse,
+  QueryBookmarkFoldersRequest,
+  QueryBookmarkFoldersResponse,
+  QueryBookmarksRequest,
+  QueryBookmarksResponse,
+  QueryCommentReactionsRequest,
+  QueryCommentReactionsResponse,
+  QueryCommentsRequest,
+  QueryCommentsResponse,
+  QueryFeedMembersRequest,
+  QueryFeedMembersResponse,
+  QueryFeedsRequest,
+  QueryFeedsResponse,
+  QueryFollowsRequest,
+  QueryFollowsResponse,
+  RejectFeedMemberInviteRequest,
+  RejectFeedMemberInviteResponse,
+  RejectFollowRequest,
+  RejectFollowResponse,
+  Response,
+  SingleFollowRequest,
+  SingleFollowResponse,
+  UnfollowBatchRequest,
+  UnfollowBatchResponse,
+  UnfollowResponse,
+  UnpinActivityResponse,
+  UpdateActivityPartialRequest,
+  UpdateActivityPartialResponse,
+  UpdateActivityRequest,
+  UpdateActivityResponse,
+  UpdateBookmarkFolderRequest,
+  UpdateBookmarkFolderResponse,
+  UpdateBookmarkRequest,
+  UpdateBookmarkResponse,
+  UpdateCommentRequest,
+  UpdateCommentResponse,
+  UpdateFeedGroupRequest,
+  UpdateFeedGroupResponse,
+  UpdateFeedMembersRequest,
+  UpdateFeedMembersResponse,
+  UpdateFeedRequest,
+  UpdateFeedResponse,
+  UpdateFeedViewRequest,
+  UpdateFeedViewResponse,
+  UpdateFollowRequest,
+  UpdateFollowResponse,
+  UpsertActivitiesRequest,
+  UpsertActivitiesResponse,
+} from '../models';
+import { decoders } from '../model-decoders/decoders';
+
+export class FeedsApi {
+  constructor(public readonly apiClient: ApiClient) {}
+
+  async addActivity(
+    request: AddActivityRequest,
+  ): Promise<StreamResponse<AddActivityResponse>> {
+    const body = {
+      type: request?.type,
+      fids: request?.fids,
+      expires_at: request?.expires_at,
+      id: request?.id,
+      parent_id: request?.parent_id,
+      poll_id: request?.poll_id,
+      text: request?.text,
+      user_id: request?.user_id,
+      visibility: request?.visibility,
+      visibility_tag: request?.visibility_tag,
+      attachments: request?.attachments,
+      filter_tags: request?.filter_tags,
+      interest_tags: request?.interest_tags,
+      mentioned_user_ids: request?.mentioned_user_ids,
+      custom: request?.custom,
+      location: request?.location,
+      search_data: request?.search_data,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddActivityResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async upsertActivities(
+    request: UpsertActivitiesRequest,
+  ): Promise<StreamResponse<UpsertActivitiesResponse>> {
+    const body = {
+      activities: request?.activities,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpsertActivitiesResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpsertActivitiesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteActivities(
+    request: DeleteActivitiesRequest,
+  ): Promise<StreamResponse<DeleteActivitiesResponse>> {
+    const body = {
+      activity_ids: request?.activity_ids,
+      hard_delete: request?.hard_delete,
+      user_id: request?.user_id,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteActivitiesResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/delete',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.DeleteActivitiesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryActivities(
+    request?: QueryActivitiesRequest,
+  ): Promise<StreamResponse<QueryActivitiesResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryActivitiesResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryActivitiesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteActivity(request: {
+    activity_id: string;
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteActivityResponse>> {
+    const queryParams = {
+      hard_delete: request?.hard_delete,
+    };
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteActivityResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/activities/{activity_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getActivity(request: {
+    activity_id: string;
+  }): Promise<StreamResponse<GetActivityResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetActivityResponse>
+    >('GET', '/api/v2/feeds/activities/{activity_id}', pathParams, undefined);
+
+    decoders.GetActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateActivityPartial(
+    request: UpdateActivityPartialRequest & { activity_id: string },
+  ): Promise<StreamResponse<UpdateActivityPartialResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      user_id: request?.user_id,
+      unset: request?.unset,
+      set: request?.set,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateActivityPartialResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/activities/{activity_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateActivityPartialResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateActivity(
+    request: UpdateActivityRequest & { activity_id: string },
+  ): Promise<StreamResponse<UpdateActivityResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      expires_at: request?.expires_at,
+      poll_id: request?.poll_id,
+      text: request?.text,
+      user_id: request?.user_id,
+      visibility: request?.visibility,
+      attachments: request?.attachments,
+      filter_tags: request?.filter_tags,
+      interest_tags: request?.interest_tags,
+      custom: request?.custom,
+      location: request?.location,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateActivityResponse>
+    >(
+      'PUT',
+      '/api/v2/feeds/activities/{activity_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteBookmark(request: {
+    activity_id: string;
+    folder_id?: string;
+    user_id?: string;
+  }): Promise<StreamResponse<DeleteBookmarkResponse>> {
+    const queryParams = {
+      folder_id: request?.folder_id,
+      user_id: request?.user_id,
+    };
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteBookmarkResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/activities/{activity_id}/bookmarks',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteBookmarkResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateBookmark(
+    request: UpdateBookmarkRequest & { activity_id: string },
+  ): Promise<StreamResponse<UpdateBookmarkResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      folder_id: request?.folder_id,
+      new_folder_id: request?.new_folder_id,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      new_folder: request?.new_folder,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateBookmarkResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/activities/{activity_id}/bookmarks',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateBookmarkResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addBookmark(
+    request: AddBookmarkRequest & { activity_id: string },
+  ): Promise<StreamResponse<AddBookmarkResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      folder_id: request?.folder_id,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      new_folder: request?.new_folder,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddBookmarkResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/{activity_id}/bookmarks',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddBookmarkResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async castPollVote(
+    request: CastPollVoteRequest & { activity_id: string; poll_id: string },
+  ): Promise<StreamResponse<PollVoteResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+      poll_id: request?.poll_id,
+    };
+    const body = {
+      user_id: request?.user_id,
+      user: request?.user,
+      vote: request?.vote,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PollVoteResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/{activity_id}/polls/{poll_id}/vote',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.PollVoteResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deletePollVote(request: {
+    activity_id: string;
+    poll_id: string;
+    vote_id: string;
+    user_id?: string;
+  }): Promise<StreamResponse<PollVoteResponse>> {
+    const queryParams = {
+      user_id: request?.user_id,
+    };
+    const pathParams = {
+      activity_id: request?.activity_id,
+      poll_id: request?.poll_id,
+      vote_id: request?.vote_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PollVoteResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/activities/{activity_id}/polls/{poll_id}/vote/{vote_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.PollVoteResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addReaction(
+    request: AddReactionRequest & { activity_id: string },
+  ): Promise<StreamResponse<AddReactionResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      type: request?.type,
+      create_notification_activity: request?.create_notification_activity,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddReactionResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/{activity_id}/reactions',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddReactionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryActivityReactions(
+    request: QueryActivityReactionsRequest & { activity_id: string },
+  ): Promise<StreamResponse<QueryActivityReactionsResponse>> {
+    const pathParams = {
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryActivityReactionsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/{activity_id}/reactions/query',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryActivityReactionsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteActivityReaction(request: {
+    activity_id: string;
+    type: string;
+    user_id?: string;
+  }): Promise<StreamResponse<DeleteActivityReactionResponse>> {
+    const queryParams = {
+      user_id: request?.user_id,
+    };
+    const pathParams = {
+      activity_id: request?.activity_id,
+      type: request?.type,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteActivityReactionResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/activities/{activity_id}/reactions/{type}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteActivityReactionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryBookmarkFolders(
+    request?: QueryBookmarkFoldersRequest,
+  ): Promise<StreamResponse<QueryBookmarkFoldersResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryBookmarkFoldersResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/bookmark_folders/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryBookmarkFoldersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteBookmarkFolder(request: {
+    folder_id: string;
+  }): Promise<StreamResponse<DeleteBookmarkFolderResponse>> {
+    const pathParams = {
+      folder_id: request?.folder_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteBookmarkFolderResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/bookmark_folders/{folder_id}',
+      pathParams,
+      undefined,
+    );
+
+    decoders.DeleteBookmarkFolderResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateBookmarkFolder(
+    request: UpdateBookmarkFolderRequest & { folder_id: string },
+  ): Promise<StreamResponse<UpdateBookmarkFolderResponse>> {
+    const pathParams = {
+      folder_id: request?.folder_id,
+    };
+    const body = {
+      name: request?.name,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateBookmarkFolderResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/bookmark_folders/{folder_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateBookmarkFolderResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryBookmarks(
+    request?: QueryBookmarksRequest,
+  ): Promise<StreamResponse<QueryBookmarksResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryBookmarksResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/bookmarks/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryBookmarksResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getComments(request: {
+    object_id: string;
+    object_type: string;
+    depth?: number;
+    sort?: string;
+    replies_limit?: number;
+    limit?: number;
+    prev?: string;
+    next?: string;
+  }): Promise<StreamResponse<GetCommentsResponse>> {
+    const queryParams = {
+      object_id: request?.object_id,
+      object_type: request?.object_type,
+      depth: request?.depth,
+      sort: request?.sort,
+      replies_limit: request?.replies_limit,
+      limit: request?.limit,
+      prev: request?.prev,
+      next: request?.next,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetCommentsResponse>
+    >('GET', '/api/v2/feeds/comments', undefined, queryParams);
+
+    decoders.GetCommentsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addComment(
+    request: AddCommentRequest,
+  ): Promise<StreamResponse<AddCommentResponse>> {
+    const body = {
+      comment: request?.comment,
+      object_id: request?.object_id,
+      object_type: request?.object_type,
+      create_notification_activity: request?.create_notification_activity,
+      parent_id: request?.parent_id,
+      user_id: request?.user_id,
+      attachments: request?.attachments,
+      mentioned_user_ids: request?.mentioned_user_ids,
+      custom: request?.custom,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddCommentResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/comments',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddCommentResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addCommentsBatch(
+    request: AddCommentsBatchRequest,
+  ): Promise<StreamResponse<AddCommentsBatchResponse>> {
+    const body = {
+      comments: request?.comments,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddCommentsBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/comments/batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddCommentsBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryComments(
+    request: QueryCommentsRequest,
+  ): Promise<StreamResponse<QueryCommentsResponse>> {
+    const body = {
+      filter: request?.filter,
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryCommentsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/comments/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryCommentsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteComment(request: {
+    comment_id: string;
+  }): Promise<StreamResponse<DeleteCommentResponse>> {
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteCommentResponse>
+    >('DELETE', '/api/v2/feeds/comments/{comment_id}', pathParams, undefined);
+
+    decoders.DeleteCommentResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getComment(request: {
+    comment_id: string;
+  }): Promise<StreamResponse<GetCommentResponse>> {
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetCommentResponse>
+    >('GET', '/api/v2/feeds/comments/{comment_id}', pathParams, undefined);
+
+    decoders.GetCommentResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateComment(
+    request: UpdateCommentRequest & { comment_id: string },
+  ): Promise<StreamResponse<UpdateCommentResponse>> {
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+    const body = {
+      comment: request?.comment,
+      custom: request?.custom,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateCommentResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/comments/{comment_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateCommentResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addCommentReaction(
+    request: AddCommentReactionRequest & { comment_id: string },
+  ): Promise<StreamResponse<AddCommentReactionResponse>> {
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+    const body = {
+      type: request?.type,
+      create_notification_activity: request?.create_notification_activity,
+      user_id: request?.user_id,
+      custom: request?.custom,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddCommentReactionResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/comments/{comment_id}/reactions',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddCommentReactionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryCommentReactions(
+    request: QueryCommentReactionsRequest & { comment_id: string },
+  ): Promise<StreamResponse<QueryCommentReactionsResponse>> {
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryCommentReactionsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/comments/{comment_id}/reactions/query',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryCommentReactionsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteCommentReaction(request: {
+    comment_id: string;
+    type: string;
+    user_id?: string;
+  }): Promise<StreamResponse<DeleteCommentReactionResponse>> {
+    const queryParams = {
+      user_id: request?.user_id,
+    };
+    const pathParams = {
+      comment_id: request?.comment_id,
+      type: request?.type,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteCommentReactionResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/comments/{comment_id}/reactions/{type}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteCommentReactionResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getCommentReplies(request: {
+    comment_id: string;
+    depth?: number;
+    sort?: string;
+    replies_limit?: number;
+    limit?: number;
+    prev?: string;
+    next?: string;
+  }): Promise<StreamResponse<GetCommentRepliesResponse>> {
+    const queryParams = {
+      depth: request?.depth,
+      sort: request?.sort,
+      replies_limit: request?.replies_limit,
+      limit: request?.limit,
+      prev: request?.prev,
+      next: request?.next,
+    };
+    const pathParams = {
+      comment_id: request?.comment_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetCommentRepliesResponse>
+    >(
+      'GET',
+      '/api/v2/feeds/comments/{comment_id}/replies',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.GetCommentRepliesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async listFeedGroups(): Promise<StreamResponse<ListFeedGroupsResponse>> {
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ListFeedGroupsResponse>
+    >('GET', '/api/v2/feeds/feed_groups', undefined, undefined);
+
+    decoders.ListFeedGroupsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createFeedGroup(
+    request: CreateFeedGroupRequest,
+  ): Promise<StreamResponse<CreateFeedGroupResponse>> {
+    const body = {
+      feed_group_id: request?.feed_group_id,
+      default_view_id: request?.default_view_id,
+      default_visibility: request?.default_visibility,
+      custom: request?.custom,
+      notification: request?.notification,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateFeedGroupResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.CreateFeedGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteFeedGroup(request: {
+    feed_group_id: string;
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteFeedGroupResponse>> {
+    const queryParams = {
+      hard_delete: request?.hard_delete,
+    };
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteFeedGroupResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/feed_groups/{feed_group_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteFeedGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getFeedGroup(request: {
+    feed_group_id: string;
+  }): Promise<StreamResponse<GetFeedGroupResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetFeedGroupResponse>
+    >(
+      'GET',
+      '/api/v2/feeds/feed_groups/{feed_group_id}',
+      pathParams,
+      undefined,
+    );
+
+    decoders.GetFeedGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateFeedGroup(
+    request: UpdateFeedGroupRequest & { feed_group_id: string },
+  ): Promise<StreamResponse<UpdateFeedGroupResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+    };
+    const body = {
+      default_view_id: request?.default_view_id,
+      custom: request?.custom,
+      notification: request?.notification,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateFeedGroupResponse>
+    >(
+      'PUT',
+      '/api/v2/feeds/feed_groups/{feed_group_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateFeedGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteFeed(request: {
+    feed_group_id: string;
+    feed_id: string;
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteFeedResponse>> {
+    const queryParams = {
+      hard_delete: request?.hard_delete,
+    };
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteFeedResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.DeleteFeedResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getOrCreateFeed(
+    request: GetOrCreateFeedRequest & {
+      feed_group_id: string;
+      feed_id: string;
+    },
+  ): Promise<StreamResponse<GetOrCreateFeedResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      user_id: request?.user_id,
+      view: request?.view,
+      watch: request?.watch,
+      activity_selector_options: request?.activity_selector_options,
+      data: request?.data,
+      external_ranking: request?.external_ranking,
+      filter: request?.filter,
+      followers_pagination: request?.followers_pagination,
+      following_pagination: request?.following_pagination,
+      interest_weights: request?.interest_weights,
+      member_pagination: request?.member_pagination,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetOrCreateFeedResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.GetOrCreateFeedResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateFeed(
+    request: UpdateFeedRequest & { feed_group_id: string; feed_id: string },
+  ): Promise<StreamResponse<UpdateFeedResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      created_by_id: request?.created_by_id,
+      custom: request?.custom,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateFeedResponse>
+    >(
+      'PUT',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateFeedResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async markActivity(
+    request: MarkActivityRequest & { feed_group_id: string; feed_id: string },
+  ): Promise<StreamResponse<Response>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      mark_all_read: request?.mark_all_read,
+      mark_all_seen: request?.mark_all_seen,
+      user_id: request?.user_id,
+      mark_read: request?.mark_read,
+      mark_watched: request?.mark_watched,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/activities/mark/batch',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.Response?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async unpinActivity(request: {
+    feed_group_id: string;
+    feed_id: string;
+    activity_id: string;
+    user_id?: string;
+  }): Promise<StreamResponse<UnpinActivityResponse>> {
+    const queryParams = {
+      user_id: request?.user_id,
+    };
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+      activity_id: request?.activity_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnpinActivityResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/activities/{activity_id}/pin',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.UnpinActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async pinActivity(
+    request: PinActivityRequest & {
+      feed_group_id: string;
+      feed_id: string;
+      activity_id: string;
+    },
+  ): Promise<StreamResponse<PinActivityResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+      activity_id: request?.activity_id,
+    };
+    const body = {
+      user_id: request?.user_id,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<PinActivityResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/activities/{activity_id}/pin',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.PinActivityResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateFeedMembers(
+    request: UpdateFeedMembersRequest & {
+      feed_group_id: string;
+      feed_id: string;
+    },
+  ): Promise<StreamResponse<UpdateFeedMembersResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      operation: request?.operation,
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      members: request?.members,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateFeedMembersResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/members',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateFeedMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async acceptFeedMemberInvite(
+    request: AcceptFeedMemberInviteRequest & {
+      feed_id: string;
+      feed_group_id: string;
+    },
+  ): Promise<StreamResponse<AcceptFeedMemberInviteResponse>> {
+    const pathParams = {
+      feed_id: request?.feed_id,
+      feed_group_id: request?.feed_group_id,
+    };
+    const body = {
+      user_id: request?.user_id,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AcceptFeedMemberInviteResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/members/accept',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AcceptFeedMemberInviteResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryFeedMembers(
+    request: QueryFeedMembersRequest & {
+      feed_group_id: string;
+      feed_id: string;
+    },
+  ): Promise<StreamResponse<QueryFeedMembersResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryFeedMembersResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/members/query',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryFeedMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async rejectFeedMemberInvite(
+    request: RejectFeedMemberInviteRequest & {
+      feed_group_id: string;
+      feed_id: string;
+    },
+  ): Promise<StreamResponse<RejectFeedMemberInviteResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      user_id: request?.user_id,
+      user: request?.user,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RejectFeedMemberInviteResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/members/reject',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.RejectFeedMemberInviteResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getFollowSuggestions(request: {
+    feed_group_id: string;
+    limit?: number;
+  }): Promise<StreamResponse<GetFollowSuggestionsResponse>> {
+    const queryParams = {
+      limit: request?.limit,
+    };
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetFollowSuggestionsResponse>
+    >(
+      'GET',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/follow_suggestions',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.GetFollowSuggestionsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async listFeedViews(): Promise<StreamResponse<ListFeedViewsResponse>> {
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ListFeedViewsResponse>
+    >('GET', '/api/v2/feeds/feed_views', undefined, undefined);
+
+    decoders.ListFeedViewsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createFeedView(
+    request: CreateFeedViewRequest,
+  ): Promise<StreamResponse<CreateFeedViewResponse>> {
+    const body = {
+      view_id: request?.view_id,
+      activity_processors: request?.activity_processors,
+      activity_selectors: request?.activity_selectors,
+      aggregation: request?.aggregation,
+      ranking: request?.ranking,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateFeedViewResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_views',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.CreateFeedViewResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteFeedView(request: {
+    view_id: string;
+  }): Promise<StreamResponse<DeleteFeedViewResponse>> {
+    const pathParams = {
+      view_id: request?.view_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteFeedViewResponse>
+    >('DELETE', '/api/v2/feeds/feed_views/{view_id}', pathParams, undefined);
+
+    decoders.DeleteFeedViewResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getFeedView(request: {
+    view_id: string;
+  }): Promise<StreamResponse<GetFeedViewResponse>> {
+    const pathParams = {
+      view_id: request?.view_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetFeedViewResponse>
+    >('GET', '/api/v2/feeds/feed_views/{view_id}', pathParams, undefined);
+
+    decoders.GetFeedViewResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateFeedView(
+    request: UpdateFeedViewRequest & { view_id: string },
+  ): Promise<StreamResponse<UpdateFeedViewResponse>> {
+    const pathParams = {
+      view_id: request?.view_id,
+    };
+    const body = {
+      activity_processors: request?.activity_processors,
+      activity_selectors: request?.activity_selectors,
+      aggregation: request?.aggregation,
+      ranking: request?.ranking,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateFeedViewResponse>
+    >(
+      'PUT',
+      '/api/v2/feeds/feed_views/{view_id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateFeedViewResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createFeedsBatch(
+    request: CreateFeedsBatchRequest,
+  ): Promise<StreamResponse<CreateFeedsBatchResponse>> {
+    const body = {
+      feeds: request?.feeds,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateFeedsBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feeds/batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.CreateFeedsBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async feedsQueryFeeds(
+    request?: QueryFeedsRequest,
+  ): Promise<StreamResponse<QueryFeedsResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      watch: request?.watch,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryFeedsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feeds/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryFeedsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateFollow(
+    request: UpdateFollowRequest,
+  ): Promise<StreamResponse<UpdateFollowResponse>> {
+    const body = {
+      source: request?.source,
+      target: request?.target,
+      create_notification_activity: request?.create_notification_activity,
+      follower_role: request?.follower_role,
+      push_preference: request?.push_preference,
+      custom: request?.custom,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateFollowResponse>
+    >(
+      'PATCH',
+      '/api/v2/feeds/follows',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateFollowResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async follow(
+    request: SingleFollowRequest,
+  ): Promise<StreamResponse<SingleFollowResponse>> {
+    const body = {
+      source: request?.source,
+      target: request?.target,
+      create_notification_activity: request?.create_notification_activity,
+      push_preference: request?.push_preference,
+      custom: request?.custom,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<SingleFollowResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.SingleFollowResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async acceptFollow(
+    request: AcceptFollowRequest,
+  ): Promise<StreamResponse<AcceptFollowResponse>> {
+    const body = {
+      source_fid: request?.source_fid,
+      target_fid: request?.target_fid,
+      follower_role: request?.follower_role,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AcceptFollowResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/accept',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AcceptFollowResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async followBatch(
+    request: FollowBatchRequest,
+  ): Promise<StreamResponse<FollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.FollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async queryFollows(
+    request?: QueryFollowsRequest,
+  ): Promise<StreamResponse<QueryFollowsResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryFollowsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryFollowsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async rejectFollow(
+    request: RejectFollowRequest,
+  ): Promise<StreamResponse<RejectFollowResponse>> {
+    const body = {
+      source_fid: request?.source_fid,
+      target_fid: request?.target_fid,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RejectFollowResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/follows/reject',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.RejectFollowResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async unfollow(request: {
+    source: string;
+    target: string;
+  }): Promise<StreamResponse<UnfollowResponse>> {
+    const pathParams = {
+      source: request?.source,
+      target: request?.target,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnfollowResponse>
+    >(
+      'DELETE',
+      '/api/v2/feeds/follows/{source}/{target}',
+      pathParams,
+      undefined,
+    );
+
+    decoders.UnfollowResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async unfollowBatch(
+    request: UnfollowBatchRequest,
+  ): Promise<StreamResponse<UnfollowBatchResponse>> {
+    const body = {
+      follows: request?.follows,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnfollowBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/unfollow/batch',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UnfollowBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteFeedUserData(request: {
+    user_id: string;
+  }): Promise<StreamResponse<DeleteFeedUserDataResponse>> {
+    const pathParams = {
+      user_id: request?.user_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<DeleteFeedUserDataResponse>
+    >('DELETE', '/api/v2/feeds/users/{user_id}/delete', pathParams, undefined);
+
+    decoders.DeleteFeedUserDataResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async exportFeedUserData(request: {
+    user_id: string;
+  }): Promise<StreamResponse<ExportFeedUserDataResponse>> {
+    const pathParams = {
+      user_id: request?.user_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ExportFeedUserDataResponse>
+    >('POST', '/api/v2/feeds/users/{user_id}/export', pathParams, undefined);
+
+    decoders.ExportFeedUserDataResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+}
diff --git a/src/gen/model-decoders/index.ts b/src/gen/model-decoders/decoders.ts
similarity index 53%
rename from src/gen/model-decoders/index.ts
rename to src/gen/model-decoders/decoders.ts
index 7ad41d2..15487d2 100644
--- a/src/gen/model-decoders/index.ts
+++ b/src/gen/model-decoders/decoders.ts
@@ -4,8 +4,10 @@ type TypeMapping = Record<string, { type: string; isSingle: boolean }>;
 
 export const decoders: Record<string, Decoder> = {};
 
-const decodeDatetimeType = (input: number) =>
-  new Date(Math.floor(input / 1000000));
+const decodeDatetimeType = (input: number | string) =>
+  typeof input === 'number'
+    ? new Date(Math.floor(input / 1000000))
+    : new Date(input);
 
 decoders.DatetimeType = decodeDatetimeType;
 
@@ -32,6 +34,20 @@ const decode = (typeMappings: TypeMapping, input?: Record<string, any>) => {
   return input;
 };
 
+decoders.AcceptFeedMemberInviteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    member: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.AcceptFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ActionLogResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -45,326 +61,376 @@ decoders.ActionLogResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.AppResponseFields = (input?: Record<string, any>) => {
+decoders.ActivityAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    event_hooks: { type: 'EventHook', isSingle: false },
-
-    call_types: { type: 'CallType', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    channel_configs: { type: 'ChannelConfig', isSingle: false },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    push_notifications: { type: 'PushNotificationFields', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.AutomodDetails = (input?: Record<string, any>) => {
+decoders.ActivityDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    result: { type: 'MessageModerationResult', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Ban = (input?: Record<string, any>) => {
+decoders.ActivityMarkEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    expires: { type: 'DatetimeType', isSingle: true },
-
-    channel: { type: 'Channel', isSingle: true },
-
-    created_by: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    target: { type: 'User', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BanResponse = (input?: Record<string, any>) => {
+decoders.ActivityMarkedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
-
-    expires: { type: 'DatetimeType', isSingle: true },
-
-    banned_by: { type: 'UserResponse', isSingle: true },
-
-    channel: { type: 'ChannelResponse', isSingle: true },
-
-    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockListResponse = (input?: Record<string, any>) => {
+decoders.ActivityPinResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockUsersResponse = (input?: Record<string, any>) => {
+decoders.ActivityPinnedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_activity: { type: 'PinActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockedUserResponse = (input?: Record<string, any>) => {
+decoders.ActivityReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    blocked_user: { type: 'UserResponse', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallParticipantResponse = (input?: Record<string, any>) => {
+decoders.ActivityReactionDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    joined_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallRecording = (input?: Record<string, any>) => {
+decoders.ActivityReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    end_time: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    start_time: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallReportResponse = (input?: Record<string, any>) => {
+decoders.ActivityRemovedFromFeedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    started_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallResponse = (input?: Record<string, any>) => {
+decoders.ActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'UserResponse', isSingle: true },
+    comments: { type: 'CommentResponse', isSingle: false },
 
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    starts_at: { type: 'DatetimeType', isSingle: true },
+    mentioned_users: { type: 'UserResponse', isSingle: false },
 
-    session: { type: 'CallSessionResponse', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    own_bookmarks: { type: 'BookmarkResponse', isSingle: false },
 
-decoders.CallSessionResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    participants: { type: 'CallParticipantResponse', isSingle: false },
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    accepted_by: { type: 'DatetimeType', isSingle: false },
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
 
-    missed_by: { type: 'DatetimeType', isSingle: false },
+    user: { type: 'UserResponse', isSingle: true },
 
-    rejected_by: { type: 'DatetimeType', isSingle: false },
+    deleted_at: { type: 'DatetimeType', isSingle: true },
 
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    edited_at: { type: 'DatetimeType', isSingle: true },
 
-    live_ended_at: { type: 'DatetimeType', isSingle: true },
+    expires_at: { type: 'DatetimeType', isSingle: true },
 
-    live_started_at: { type: 'DatetimeType', isSingle: true },
+    current_feed: { type: 'FeedResponse', isSingle: true },
 
-    started_at: { type: 'DatetimeType', isSingle: true },
+    parent: { type: 'ActivityResponse', isSingle: true },
 
-    timer_ends_at: { type: 'DatetimeType', isSingle: true },
+    poll: { type: 'PollResponseData', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallStateResponseFields = (input?: Record<string, any>) => {
+decoders.ActivitySelectorConfig = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'MemberResponse', isSingle: false },
-
-    call: { type: 'CallResponse', isSingle: true },
+    cutoff_time: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallStatsReportSummaryResponse = (input?: Record<string, any>) => {
+decoders.ActivityUnpinnedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    first_stats_time: { type: 'DatetimeType', isSingle: true },
-
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_activity: { type: 'PinActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallTranscription = (input?: Record<string, any>) => {
+decoders.ActivityUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    end_time: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    start_time: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallType = (input?: Record<string, any>) => {
+decoders.AddActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallTypeResponse = (input?: Record<string, any>) => {
+decoders.AddBookmarkResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CampaignResponse = (input?: Record<string, any>) => {
+decoders.AddCommentReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    segments: { type: 'Segment', isSingle: false },
-
-    users: { type: 'UserResponse', isSingle: false },
-
-    stats: { type: 'CampaignStatsResponse', isSingle: true },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    scheduled_for: { type: 'DatetimeType', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    stop_at: { type: 'DatetimeType', isSingle: true },
+decoders.AddCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    sender: { type: 'UserResponse', isSingle: true },
+decoders.AddCommentsBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'CommentResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CampaignStatsResponse = (input?: Record<string, any>) => {
+decoders.AddReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    stats_completed_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    stats_started_at: { type: 'DatetimeType', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Channel = (input?: Record<string, any>) => {
+decoders.AggregatedActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_message_at: { type: 'DatetimeType', isSingle: true },
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
 
-    active_live_locations: { type: 'SharedLocation', isSingle: false },
+decoders.AnyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invites: { type: 'ChannelMember', isSingle: false },
+decoders.AppResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    event_hooks: { type: 'EventHook', isSingle: false },
 
-    members: { type: 'ChannelMember', isSingle: false },
+    call_types: { type: 'CallType', isSingle: false },
 
-    config: { type: 'ChannelConfig', isSingle: true },
+    channel_configs: { type: 'ChannelConfig', isSingle: false },
 
-    created_by: { type: 'User', isSingle: true },
+    push_notifications: { type: 'PushNotificationFields', isSingle: true },
 
-    truncated_by: { type: 'User', isSingle: true },
+    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelConfig = (input?: Record<string, any>) => {
+decoders.AsyncBulkImageModerationEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
+decoders.AsyncExportChannelsEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    commands: { type: 'Command', isSingle: false },
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMember = (input?: Record<string, any>) => {
+decoders.AsyncExportErrorEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    archived_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    ban_expires: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+decoders.AsyncExportModerationLogsEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    pinned_at: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMemberResponse = (input?: Record<string, any>) => {
+decoders.AsyncExportUsersEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    archived_at: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    ban_expires: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+decoders.AutomodDetails = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    result: { type: 'MessageModerationResult', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+decoders.Ban = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+    expires: { type: 'DatetimeType', isSingle: true },
 
-    pinned_at: { type: 'DatetimeType', isSingle: true },
+    channel: { type: 'Channel', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    created_by: { type: 'User', isSingle: true },
+
+    target: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMute = (input?: Record<string, any>) => {
+decoders.BanResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
     expires: { type: 'DatetimeType', isSingle: true },
 
+    banned_by: { type: 'UserResponse', isSingle: true },
+
     channel: { type: 'ChannelResponse', isSingle: true },
 
     user: { type: 'UserResponse', isSingle: true },
@@ -372,143 +438,1370 @@ decoders.ChannelMute = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.ChannelPushPreferences = (input?: Record<string, any>) => {
+decoders.BlockListResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    disabled_until: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelResponse = (input?: Record<string, any>) => {
+decoders.BlockUsersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+decoders.BlockedUserEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
+
+    blocked_by_user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BlockedUserResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    blocked_user: { type: 'UserResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+
+    folder: { type: 'BookmarkFolderResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallAcceptedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallCreatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallEndedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingFrameReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    captured_at: { type: 'DatetimeType', isSingle: true },
+
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    users: { type: 'UserResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallLiveStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberRemovedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberUpdatedPermissionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMissedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallModerationBlurEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallModerationWarningEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallNotificationEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallParticipantResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    joined_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallReactionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    reaction: { type: 'ReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecording = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    end_time: { type: 'DatetimeType', isSingle: true },
+
+    start_time: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call_recording: { type: 'CallRecording', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRejectedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallReportResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    starts_at: { type: 'DatetimeType', isSingle: true },
+
+    session: { type: 'CallSessionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRingEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionEndedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionParticipantJoinedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    participant: { type: 'CallParticipantResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionParticipantLeftEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    participant: { type: 'CallParticipantResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    participants: { type: 'CallParticipantResponse', isSingle: false },
+
+    accepted_by: { type: 'DatetimeType', isSingle: false },
+
+    missed_by: { type: 'DatetimeType', isSingle: false },
+
+    rejected_by: { type: 'DatetimeType', isSingle: false },
+
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    live_ended_at: { type: 'DatetimeType', isSingle: true },
+
+    live_started_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    timer_ends_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStateResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStatsReportReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStatsReportSummaryResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    first_stats_time: { type: 'DatetimeType', isSingle: true },
+
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscription = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    end_time: { type: 'DatetimeType', isSingle: true },
+
+    start_time: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call_transcription: { type: 'CallTranscription', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallType = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUserFeedbackSubmittedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUserMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignCompletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    campaign: { type: 'CampaignResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    segments: { type: 'Segment', isSingle: false },
+
+    users: { type: 'UserResponse', isSingle: false },
+
+    stats: { type: 'CampaignStatsResponse', isSingle: true },
+
+    scheduled_for: { type: 'DatetimeType', isSingle: true },
+
+    stop_at: { type: 'DatetimeType', isSingle: true },
+
+    sender: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    campaign: { type: 'CampaignResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignStatsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    stats_completed_at: { type: 'DatetimeType', isSingle: true },
+
+    stats_started_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Channel = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    last_message_at: { type: 'DatetimeType', isSingle: true },
+
+    active_live_locations: { type: 'SharedLocation', isSingle: false },
+
+    invites: { type: 'ChannelMember', isSingle: false },
+
+    members: { type: 'ChannelMember', isSingle: false },
+
+    config: { type: 'ChannelConfig', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    truncated_by: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelConfig = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    commands: { type: 'Command', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelCreatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelFrozenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelHiddenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMember = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    archived_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMemberResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    archived_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMute = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    expires: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelPushPreferences = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    disabled_until: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+
+    last_message_at: { type: 'DatetimeType', isSingle: true },
+
+    mute_expires_at: { type: 'DatetimeType', isSingle: true },
+
+    truncated_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'ChannelMember', isSingle: false },
+
+    config: { type: 'ChannelConfigWithInfo', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    truncated_by: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelStateResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'ChannelMember', isSingle: false },
+
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    pinned_messages: { type: 'MessageResponse', isSingle: false },
+
+    threads: { type: 'ThreadStateResponse', isSingle: false },
+
+    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+
+    active_live_locations: {
+      type: 'SharedLocationResponseData',
+      isSingle: false,
+    },
+
+    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+
+    read: { type: 'ReadStateResponse', isSingle: false },
+
+    watchers: { type: 'UserResponse', isSingle: false },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    draft: { type: 'DraftResponse', isSingle: true },
+
+    membership: { type: 'ChannelMember', isSingle: true },
+
+    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelStateResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'ChannelMember', isSingle: false },
+
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    pinned_messages: { type: 'MessageResponse', isSingle: false },
+
+    threads: { type: 'ThreadStateResponse', isSingle: false },
 
     hide_messages_before: { type: 'DatetimeType', isSingle: true },
 
-    last_message_at: { type: 'DatetimeType', isSingle: true },
+    active_live_locations: {
+      type: 'SharedLocationResponseData',
+      isSingle: false,
+    },
+
+    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+
+    read: { type: 'ReadStateResponse', isSingle: false },
+
+    watchers: { type: 'UserResponse', isSingle: false },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    draft: { type: 'DraftResponse', isSingle: true },
+
+    membership: { type: 'ChannelMember', isSingle: true },
+
+    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelTruncatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelTypeConfig = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    commands: { type: 'Command', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUnFrozenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUnmutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelVisibleEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChatActivityStatsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    messages: { type: 'MessageStatsResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CheckResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ClosedCaptionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Command = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    mute_expires_at: { type: 'DatetimeType', isSingle: true },
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    truncated_at: { type: 'DatetimeType', isSingle: true },
+decoders.CommentAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    members: { type: 'ChannelMember', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    config: { type: 'ChannelConfigWithInfo', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'UserResponse', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    truncated_by: { type: 'UserResponse', isSingle: true },
+decoders.CommentDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    comment: { type: 'CommentResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelStateResponse = (input?: Record<string, any>) => {
+decoders.CommentReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'ChannelMember', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    messages: { type: 'MessageResponse', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    pinned_messages: { type: 'MessageResponse', isSingle: false },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    threads: { type: 'ThreadStateResponse', isSingle: false },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    active_live_locations: {
-      type: 'SharedLocationResponseData',
-      isSingle: false,
-    },
+decoders.CommentReactionDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    read: { type: 'ReadStateResponse', isSingle: false },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    watchers: { type: 'UserResponse', isSingle: false },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    channel: { type: 'ChannelResponse', isSingle: true },
+decoders.CommentReactionUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    draft: { type: 'DraftResponse', isSingle: true },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    membership: { type: 'ChannelMember', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelStateResponseFields = (input?: Record<string, any>) => {
+decoders.CommentResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'ChannelMember', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    messages: { type: 'MessageResponse', isSingle: false },
+    updated_at: { type: 'DatetimeType', isSingle: true },
 
-    pinned_messages: { type: 'MessageResponse', isSingle: false },
+    mentioned_users: { type: 'UserResponse', isSingle: false },
 
-    threads: { type: 'ThreadStateResponse', isSingle: false },
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
 
-    active_live_locations: {
-      type: 'SharedLocationResponseData',
-      isSingle: false,
-    },
+    deleted_at: { type: 'DatetimeType', isSingle: true },
 
-    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    read: { type: 'ReadStateResponse', isSingle: false },
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
 
-    watchers: { type: 'UserResponse', isSingle: false },
+decoders.CommentUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    comment: { type: 'CommentResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ConfigResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CountByMinuteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    start_ts: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateBlockListResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    blocklist: { type: 'BlockListResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateCallTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateChannelTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateCommandResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    command: { type: 'Command', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedsBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feeds: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateGuestResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateImportResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    import_task: { type: 'ImportTask', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateRoleResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    role: { type: 'Role', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CustomCheckResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CustomVideoEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeactivateUserResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteActivityReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteBookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
+decoders.DeleteCallResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteChannelResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    draft: { type: 'DraftResponse', isSingle: true },
+decoders.DeleteCommentReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    membership: { type: 'ChannelMember', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteMessageResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    message: { type: 'MessageResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    message: { type: 'MessageResponse', isSingle: true },
+
+    reaction: { type: 'ReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Device = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeviceResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+decoders.DraftPayloadResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    mentioned_users: { type: 'UserResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelTypeConfig = (input?: Record<string, any>) => {
+decoders.DraftResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    message: { type: 'DraftPayloadResponse', isSingle: true },
 
-    commands: { type: 'Command', isSingle: false },
-  };
-  return decode(typeMappings, input);
-};
+    channel: { type: 'ChannelResponse', isSingle: true },
 
-decoders.ChatActivityStatsResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    messages: { type: 'MessageStatsResponse', isSingle: true },
+    parent_message: { type: 'MessageResponse', isSingle: true },
+
+    quoted_message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CheckResponse = (input?: Record<string, any>) => {
+decoders.EgressRTMPResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Command = (input?: Record<string, any>) => {
+decoders.EntityCreatorResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deactivated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    last_active: { type: 'DatetimeType', isSingle: true },
+
+    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
+
+    devices: { type: 'DeviceResponse', isSingle: false },
+
+    push_notifications: {
+      type: 'PushNotificationSettingsResponse',
+      isSingle: true,
+    },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ConfigResponse = (input?: Record<string, any>) => {
+decoders.EventHook = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
@@ -517,216 +1810,259 @@ decoders.ConfigResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.CountByMinuteResponse = (input?: Record<string, any>) => {
+decoders.EventResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    start_ts: { type: 'DatetimeType', isSingle: true },
+    event: { type: 'WSEvent', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateBlockListResponse = (input?: Record<string, any>) => {
+decoders.ExportUserResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    blocklist: { type: 'BlockListResponse', isSingle: true },
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    reactions: { type: 'ReactionResponse', isSingle: false },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateCallTypeResponse = (input?: Record<string, any>) => {
+decoders.FeedCreatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    members: { type: 'FeedMemberResponse', isSingle: false },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateChannelTypeResponse = (input?: Record<string, any>) => {
+decoders.FeedDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateCommandResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupChangedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    command: { type: 'Command', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateGuestResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    user: { type: 'UserResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateImportResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    import_task: { type: 'ImportTask', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateRoleResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    role: { type: 'Role', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'FeedMemberResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CustomCheckResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberRemovedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeactivateUserResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
     user: { type: 'UserResponse', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteCallResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    call: { type: 'CallResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'FeedMemberResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteChannelResponse = (input?: Record<string, any>) => {
+decoders.FeedResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    channel: { type: 'ChannelResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteMessageResponse = (input?: Record<string, any>) => {
+decoders.FeedUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    message: { type: 'MessageResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteReactionResponse = (input?: Record<string, any>) => {
+decoders.FeedViewResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    message: { type: 'MessageResponse', isSingle: true },
+    last_used_at: { type: 'DatetimeType', isSingle: true },
 
-    reaction: { type: 'ReactionResponse', isSingle: true },
+    activity_selectors: { type: 'ActivitySelectorConfig', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Device = (input?: Record<string, any>) => {
+decoders.FeedsReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeviceResponse = (input?: Record<string, any>) => {
+decoders.FlagDetails = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
+    automod: { type: 'AutomodDetails', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DraftPayloadResponse = (input?: Record<string, any>) => {
+decoders.FlagFeedback = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    mentioned_users: { type: 'UserResponse', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DraftResponse = (input?: Record<string, any>) => {
+decoders.FlagUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'DraftPayloadResponse', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    channel: { type: 'ChannelResponse', isSingle: true },
+    created_by: { type: 'UserResponse', isSingle: true },
 
-    parent_message: { type: 'MessageResponse', isSingle: true },
+    message: { type: 'MessageResponse', isSingle: true },
 
-    quoted_message: { type: 'MessageResponse', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EgressRTMPResponse = (input?: Record<string, any>) => {
+decoders.FollowBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    started_at: { type: 'DatetimeType', isSingle: true },
+    follows: { type: 'FollowResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EntityCreatorResponse = (input?: Record<string, any>) => {
+decoders.FollowCreatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    ban_expires: { type: 'DatetimeType', isSingle: true },
-
-    deactivated_at: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_active: { type: 'DatetimeType', isSingle: true },
-
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
-
-    devices: { type: 'DeviceResponse', isSingle: false },
+    follow: { type: 'FollowResponse', isSingle: true },
 
-    push_notifications: {
-      type: 'PushNotificationSettingsResponse',
-      isSingle: true,
-    },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EventHook = (input?: Record<string, any>) => {
+decoders.FollowDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    follow: { type: 'FollowResponse', isSingle: true },
 
-decoders.EventResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    event: { type: 'WSEvent', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ExportUserResponse = (input?: Record<string, any>) => {
+decoders.FollowResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    messages: { type: 'MessageResponse', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    reactions: { type: 'ReactionResponse', isSingle: false },
+    updated_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    source_feed: { type: 'FeedResponse', isSingle: true },
 
-decoders.FlagDetails = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    automod: { type: 'AutomodDetails', isSingle: true },
+    target_feed: { type: 'FeedResponse', isSingle: true },
+
+    request_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    request_rejected_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.FlagFeedback = (input?: Record<string, any>) => {
+decoders.FollowUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    follow: { type: 'FollowResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -765,6 +2101,13 @@ decoders.GetActiveCallsStatusResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetApplicationResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     app: { type: 'AppResponseFields', isSingle: true },
@@ -833,6 +2176,27 @@ decoders.GetCommandResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetCommentRepliesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'ThreadedCommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetCommentsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'ThreadedCommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetConfigResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     config: { type: 'ConfigResponse', isSingle: true },
@@ -847,6 +2211,27 @@ decoders.GetDraftResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetFollowSuggestionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    suggestions: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetImportResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     import_task: { type: 'ImportTask', isSingle: true },
@@ -877,6 +2262,34 @@ decoders.GetOrCreateCallResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetOrCreateFeedResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+
+    aggregated_activities: {
+      type: 'AggregatedActivityResponse',
+      isSingle: false,
+    },
+
+    followers: { type: 'FollowResponse', isSingle: false },
+
+    following: { type: 'FollowResponse', isSingle: false },
+
+    members: { type: 'FeedMemberResponse', isSingle: false },
+
+    pinned_activities: { type: 'ActivityPinResponse', isSingle: false },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    own_follows: { type: 'FollowResponse', isSingle: false },
+
+    notification_status: { type: 'NotificationStatusResponse', isSingle: true },
+
+    own_membership: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetPushTemplatesResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     templates: { type: 'PushTemplate', isSingle: false },
@@ -988,6 +2401,20 @@ decoders.ListDevicesResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ListFeedGroupsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    groups: { type: 'FeedGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ListFeedViewsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    views: { type: 'FeedViewResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ListImportsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     import_tasks: { type: 'ImportTask', isSingle: false },
@@ -1030,6 +2457,28 @@ decoders.MarkReadResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MemberAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MemberRemovedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MemberResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1043,6 +2492,17 @@ decoders.MemberResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MemberUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'ChannelMember', isSingle: false },
@@ -1089,6 +2549,19 @@ decoders.Message = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1116,6 +2589,19 @@ decoders.MessageFlagResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageHistoryEntryResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     message_updated_at: { type: 'DatetimeType', isSingle: true },
@@ -1132,6 +2618,19 @@ decoders.MessageModerationResult = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageNewEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageReadEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1210,6 +2709,45 @@ decoders.MessageStatsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageUnblockedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MessageUndeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MessageUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageWithChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1253,6 +2791,26 @@ decoders.MessageWithChannelResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ModerationCheckCompletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
@@ -1262,6 +2820,26 @@ decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ModerationFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ModerationMarkReviewedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MuteChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel_mutes: { type: 'ChannelMute', isSingle: false },
@@ -1282,6 +2860,26 @@ decoders.MuteResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.NotificationMarkUnreadEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    last_read_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.NotificationStatusResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    last_seen_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.OwnUser = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1346,6 +2944,21 @@ decoders.ParticipantCountOverTimeResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.PendingMessageEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'Channel', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.PendingMessageResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
@@ -1357,6 +2970,24 @@ decoders.PendingMessageResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.PermissionRequestEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.PinActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Poll = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1484,6 +3115,20 @@ decoders.PushTemplate = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryActivitiesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryActivityReactionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    reactions: { type: 'FeedsReactionResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryBannedUsersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     bans: { type: 'BanResponse', isSingle: false },
@@ -1491,6 +3136,20 @@ decoders.QueryBannedUsersResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryBookmarkFoldersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark_folders: { type: 'BookmarkFolderResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryBookmarksResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmarks: { type: 'BookmarkResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryCallMembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'MemberResponse', isSingle: false },
@@ -1537,6 +3196,20 @@ decoders.QueryChannelsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryCommentReactionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    reactions: { type: 'FeedsReactionResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryCommentsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'CommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryDraftsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     drafts: { type: 'DraftResponse', isSingle: false },
@@ -1544,6 +3217,13 @@ decoders.QueryDraftsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryFeedMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'FeedMemberResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryFeedModerationTemplate = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1562,6 +3242,20 @@ decoders.QueryFeedModerationTemplatesResponse = (
   return decode(typeMappings, input);
 };
 
+decoders.QueryFeedsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feeds: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryFollowsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follows: { type: 'FollowResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryMessageFlagsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     flags: { type: 'MessageFlagResponse', isSingle: false },
@@ -1646,40 +3340,83 @@ decoders.QueryThreadsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.QueryUsersResponse = (input?: Record<string, any>) => {
+decoders.QueryUsersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    users: { type: 'FullUserResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Reaction = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ReactionDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    reaction: { type: 'Reaction', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ReactionGroupResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    users: { type: 'FullUserResponse', isSingle: false },
+    first_reaction_at: { type: 'DatetimeType', isSingle: true },
+
+    last_reaction_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Reaction = (input?: Record<string, any>) => {
+decoders.ReactionNewEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    reaction: { type: 'Reaction', isSingle: true },
 
     user: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ReactionGroupResponse = (input?: Record<string, any>) => {
+decoders.ReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    first_reaction_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    last_reaction_at: { type: 'DatetimeType', isSingle: true },
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ReactionResponse = (input?: Record<string, any>) => {
+decoders.ReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    message: { type: 'Message', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    reaction: { type: 'Reaction', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1700,6 +3437,20 @@ decoders.ReadStateResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.RejectFeedMemberInviteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    member: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.RejectFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReminderResponseData = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1717,6 +3468,19 @@ decoders.ReminderResponseData = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ReviewQueueItemNewEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    action: { type: 'ActionLogResponse', isSingle: true },
+
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1746,6 +3510,19 @@ decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ReviewQueueItemUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    action: { type: 'ActionLogResponse', isSingle: true },
+
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Role = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1905,6 +3682,13 @@ decoders.SharedLocationsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.SingleFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.StopLiveResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     call: { type: 'CallResponse', isSingle: true },
@@ -1982,6 +3766,40 @@ decoders.ThreadStateResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ThreadUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread: { type: 'ThreadResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ThreadedCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    mentioned_users: { type: 'UserResponse', isSingle: false },
+
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
+
+    user: { type: 'UserResponse', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
+
+    replies: { type: 'ThreadedCommentResponse', isSingle: false },
+
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.TruncateChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
@@ -1991,6 +3809,22 @@ decoders.TruncateChannelResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UnblockedUserEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UnpinActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UnreadCountsBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     counts_by_user: { type: 'UnreadCountsResponse', isSingle: false },
@@ -2021,6 +3855,20 @@ decoders.UnreadCountsThread = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateActivityPartialResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateBlockListResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     blocklist: { type: 'BlockListResponse', isSingle: true },
@@ -2028,6 +3876,20 @@ decoders.UpdateBlockListResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateBookmarkFolderResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateBookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateCallMembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'MemberResponse', isSingle: false },
@@ -2089,6 +3951,50 @@ decoders.UpdateCommandResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    added: { type: 'FeedMemberResponse', isSingle: false },
+
+    updated: { type: 'FeedMemberResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed: { type: 'FeedResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateMemberPartialResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel_member: { type: 'ChannelMemberResponse', isSingle: true },
@@ -2131,6 +4037,22 @@ decoders.UpdateUsersResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdatedCallPermissionsEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpsertActivitiesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpsertConfigResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     config: { type: 'ConfigResponse', isSingle: true },
@@ -2189,6 +4111,48 @@ decoders.User = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserBannedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    expiration: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserDeactivatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserMute = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -2219,6 +4183,24 @@ decoders.UserMuteResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserReactivatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -2262,6 +4244,42 @@ decoders.UserResponseCommonFields = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserUnbannedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUnmutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUnreadReminderEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.VideoReactionOverTimeResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     by_minute: { type: 'CountByMinuteResponse', isSingle: false },
diff --git a/src/gen/models/index.ts b/src/gen/models/index.ts
index 4cdfa6d..9bc6e5f 100644
--- a/src/gen/models/index.ts
+++ b/src/gen/models/index.ts
@@ -118,6 +118,32 @@ export interface AWSRekognitionRule {
   min_confidence: number;
 }
 
+export interface AcceptFeedMemberInviteRequest {
+  user_id?: string;
+
+  user?: UserRequest;
+}
+
+export interface AcceptFeedMemberInviteResponse {
+  duration: string;
+
+  member: FeedMemberResponse;
+}
+
+export interface AcceptFollowRequest {
+  source_fid: string;
+
+  target_fid: string;
+
+  follower_role?: string;
+}
+
+export interface AcceptFollowResponse {
+  duration: string;
+
+  follow: FollowResponse;
+}
+
 export interface Action {
   name: string;
 
@@ -226,868 +252,1458 @@ export interface ActiveCallsSummary {
   participants: number;
 }
 
-export interface AnyEvent {
+export interface ActivityAddedEvent {
   created_at: Date;
 
-  type: string;
-}
-
-export interface AppResponseFields {
-  async_url_enrich_enabled: boolean;
+  fid: string;
 
-  auto_translation_enabled: boolean;
+  activity: ActivityResponse;
 
-  campaign_enabled: boolean;
+  custom: Record<string, any>;
 
-  cdn_expiration_seconds: number;
+  type: string;
 
-  custom_action_handler_url: string;
+  received_at?: Date;
 
-  disable_auth_checks: boolean;
+  user?: UserResponseCommonFields;
+}
 
-  disable_permissions_checks: boolean;
+export interface ActivityDeletedEvent {
+  created_at: Date;
 
-  enforce_unique_usernames: string;
+  fid: string;
 
-  guest_user_creation_disabled: boolean;
+  activity: ActivityResponse;
 
-  image_moderation_enabled: boolean;
+  custom: Record<string, any>;
 
-  moderation_enabled: boolean;
+  type: string;
 
-  moderation_multitenant_blocklist_enabled: boolean;
+  received_at?: Date;
 
-  moderation_webhook_url: string;
+  user?: UserResponseCommonFields;
+}
 
-  multi_tenant_enabled: boolean;
+export interface ActivityLocation {
+  lat: number;
 
-  name: string;
+  lng: number;
+}
 
-  organization: string;
+export interface ActivityMarkEvent {
+  created_at: Date;
 
-  permission_version: string;
+  fid: string;
 
-  reminders_interval: number;
+  custom: Record<string, any>;
 
-  sns_key: string;
+  type: string;
 
-  sns_secret: string;
+  mark_all_read?: boolean;
 
-  sns_topic_arn: string;
+  mark_all_seen?: boolean;
 
-  sqs_key: string;
+  received_at?: Date;
 
-  sqs_secret: string;
+  mark_read?: string[];
 
-  sqs_url: string;
+  mark_watched?: string[];
 
-  suspended: boolean;
+  user?: UserResponseCommonFields;
+}
 
-  suspended_explanation: string;
+export interface ActivityMarkedEvent {
+  all_read: boolean;
 
-  use_hook_v2: boolean;
+  all_seen: boolean;
 
-  webhook_url: string;
+  created_at: Date;
 
-  event_hooks: EventHook[];
+  feed_id: string;
 
-  user_search_disallowed_roles: string[];
+  user_id: string;
 
-  webhook_events: string[];
+  type: string;
 
-  call_types: Record<string, CallType>;
+  marked_read?: string[];
 
-  channel_configs: Record<string, ChannelConfig>;
+  marked_watched?: string[];
+}
 
-  file_upload_config: FileUploadConfig;
+export interface ActivityPinResponse {
+  created_at: Date;
 
-  grants: Record<string, string[]>;
+  feed: string;
 
-  image_upload_config: FileUploadConfig;
+  updated_at: Date;
 
-  policies: Record<string, Policy[]>;
+  activity: ActivityResponse;
 
-  push_notifications: PushNotificationFields;
+  user: UserResponse;
+}
 
-  before_message_send_hook_url?: string;
+export interface ActivityPinnedEvent {
+  created_at: Date;
 
-  revoke_tokens_issued_before?: Date;
+  fid: string;
 
-  allowed_flag_reasons?: string[];
+  custom: Record<string, any>;
 
-  geofences?: GeofenceResponse[];
+  pinned_activity: PinActivityResponse;
 
-  image_moderation_labels?: string[];
+  type: string;
 
-  datadog_info?: DataDogInfo;
+  received_at?: Date;
 
-  moderation_dashboard_preferences?: ModerationDashboardPreferences;
+  user?: UserResponseCommonFields;
 }
 
-export interface AsyncBulkImageModerationEvent {
-  created_at: Date;
-
-  finished_at: Date;
+export interface ActivityProcessorConfig {}
 
-  started_at: Date;
+export interface ActivityReactionAddedEvent {
+  created_at: Date;
 
-  task_id: string;
+  fid: string;
 
-  url: string;
+  activity: ActivityResponse;
 
   custom: Record<string, any>;
 
+  reaction: FeedsReactionResponse;
+
   type: string;
 
   received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AsyncExportChannelsEvent {
+export interface ActivityReactionDeletedEvent {
   created_at: Date;
 
-  finished_at: Date;
-
-  started_at: Date;
-
-  task_id: string;
+  fid: string;
 
-  url: string;
+  activity: ActivityResponse;
 
   custom: Record<string, any>;
 
+  reaction: FeedsReactionResponse;
+
   type: string;
 
   received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AsyncExportErrorEvent {
+export interface ActivityReactionUpdatedEvent {
   created_at: Date;
 
-  error: string;
-
-  finished_at: Date;
-
-  started_at: Date;
+  fid: string;
 
-  task_id: string;
+  activity: ActivityResponse;
 
   custom: Record<string, any>;
 
+  reaction: FeedsReactionResponse;
+
   type: string;
 
   received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AsyncExportModerationLogsEvent {
+export interface ActivityRemovedFromFeedEvent {
   created_at: Date;
 
-  finished_at: Date;
-
-  started_at: Date;
-
-  task_id: string;
+  fid: string;
 
-  url: string;
+  activity: ActivityResponse;
 
   custom: Record<string, any>;
 
   type: string;
 
   received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AsyncExportUsersEvent {
-  created_at: Date;
+export interface ActivityRequest {
+  type: string;
 
-  finished_at: Date;
+  fids: string[];
 
-  started_at: Date;
+  expires_at?: string;
 
-  task_id: string;
+  id?: string;
 
-  url: string;
+  parent_id?: string;
 
-  custom: Record<string, any>;
+  poll_id?: string;
 
-  type: string;
+  text?: string;
 
-  received_at?: Date;
-}
+  user_id?: string;
 
-export interface AsyncModerationCallbackConfig {
-  mode?: 'CALLBACK_MODE_NONE' | 'CALLBACK_MODE_REST' | 'CALLBACK_MODE_TWIRP';
+  visibility?: 'public' | 'private' | 'tag';
 
-  server_url?: string;
-}
+  visibility_tag?: string;
 
-export interface AsyncModerationConfiguration {
-  timeout_ms?: number;
+  attachments?: Attachment[];
 
-  callback?: AsyncModerationCallbackConfig;
-}
+  filter_tags?: string[];
 
-export interface Attachment {
-  custom: Record<string, any>;
+  interest_tags?: string[];
 
-  asset_url?: string;
+  mentioned_user_ids?: string[];
 
-  author_icon?: string;
+  custom?: Record<string, any>;
 
-  author_link?: string;
+  location?: ActivityLocation;
 
-  author_name?: string;
+  search_data?: Record<string, any>;
+}
 
-  color?: string;
+export interface ActivityResponse {
+  bookmark_count: number;
 
-  fallback?: string;
+  comment_count: number;
 
-  footer?: string;
+  created_at: Date;
 
-  footer_icon?: string;
+  id: string;
 
-  image_url?: string;
+  popularity: number;
 
-  og_scrape_url?: string;
+  reaction_count: number;
 
-  original_height?: number;
+  score: number;
 
-  original_width?: number;
+  share_count: number;
 
-  pretext?: string;
+  type: string;
 
-  text?: string;
+  updated_at: Date;
 
-  thumb_url?: string;
+  visibility: 'public' | 'private' | 'tag';
 
-  title?: string;
+  attachments: Attachment[];
 
-  title_link?: string;
+  comments: CommentResponse[];
 
-  type?: string;
+  feeds: string[];
 
-  actions?: Action[];
+  filter_tags: string[];
 
-  fields?: Field[];
+  interest_tags: string[];
 
-  giphy?: Images;
-}
+  latest_reactions: FeedsReactionResponse[];
 
-export interface AudioSettings {
-  access_request_enabled: boolean;
+  mentioned_users: UserResponse[];
 
-  default_device: 'speaker' | 'earpiece';
+  own_bookmarks: BookmarkResponse[];
 
-  mic_default_on: boolean;
+  own_reactions: FeedsReactionResponse[];
 
-  opus_dtx_enabled: boolean;
+  custom: Record<string, any>;
 
-  redundant_coding_enabled: boolean;
+  reaction_groups: Record<string, ReactionGroupResponse>;
 
-  speaker_default_on: boolean;
+  search_data: Record<string, any>;
 
-  noise_cancellation?: NoiseCancellationSettings;
-}
+  user: UserResponse;
 
-export interface AudioSettingsRequest {
-  default_device: 'speaker' | 'earpiece';
+  deleted_at?: Date;
 
-  access_request_enabled?: boolean;
+  edited_at?: Date;
 
-  mic_default_on?: boolean;
+  expires_at?: Date;
 
-  opus_dtx_enabled?: boolean;
+  text?: string;
 
-  redundant_coding_enabled?: boolean;
+  visibility_tag?: string;
 
-  speaker_default_on?: boolean;
+  current_feed?: FeedResponse;
 
-  noise_cancellation?: NoiseCancellationSettings;
-}
+  location?: ActivityLocation;
 
-export interface AudioSettingsResponse {
-  access_request_enabled: boolean;
+  moderation?: ModerationV2Response;
 
-  default_device: 'speaker' | 'earpiece';
+  object?: Record<string, any>;
 
-  mic_default_on: boolean;
+  parent?: ActivityResponse;
 
-  opus_dtx_enabled: boolean;
+  poll?: PollResponseData;
+}
 
-  redundant_coding_enabled: boolean;
+export interface ActivitySelectorConfig {
+  cutoff_time?: Date;
 
-  speaker_default_on: boolean;
+  min_popularity?: number;
 
-  noise_cancellation?: NoiseCancellationSettings;
+  type?: string;
+
+  sort?: SortParam[];
+
+  filter?: Record<string, any>;
 }
 
-export interface AutomodDetails {
-  action?: string;
+export interface ActivityUnpinnedEvent {
+  created_at: Date;
 
-  original_message_type?: string;
+  fid: string;
 
-  image_labels?: string[];
+  custom: Record<string, any>;
 
-  message_details?: FlagMessageDetails;
+  pinned_activity: PinActivityResponse;
 
-  result?: MessageModerationResult;
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AutomodPlatformCircumventionConfig {
-  enabled: boolean;
+export interface ActivityUpdatedEvent {
+  created_at: Date;
 
-  rules: AutomodRule[];
+  fid: string;
 
-  async?: boolean;
-}
+  activity: ActivityResponse;
 
-export interface AutomodRule {
-  action:
-    | 'flag'
-    | 'shadow'
-    | 'remove'
-    | 'bounce'
-    | 'bounce_flag'
-    | 'bounce_remove';
+  custom: Record<string, any>;
 
-  label: string;
+  type: string;
 
-  threshold: number;
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface AutomodSemanticFiltersConfig {
-  enabled: boolean;
+export interface AddActivityRequest {
+  type: string;
 
-  rules: AutomodSemanticFiltersRule[];
+  fids: string[];
 
-  async?: boolean;
-}
+  expires_at?: string;
 
-export interface AutomodSemanticFiltersRule {
-  action: 'flag' | 'shadow' | 'remove';
+  id?: string;
 
-  name: string;
+  parent_id?: string;
 
-  threshold: number;
-}
+  poll_id?: string;
 
-export interface AutomodToxicityConfig {
-  enabled: boolean;
+  text?: string;
 
-  rules: AutomodRule[];
+  user_id?: string;
 
-  async?: boolean;
-}
+  visibility?: 'public' | 'private' | 'tag';
 
-export interface AzureRequest {
-  abs_account_name: string;
+  visibility_tag?: string;
 
-  abs_client_id: string;
+  attachments?: Attachment[];
 
-  abs_client_secret: string;
+  filter_tags?: string[];
 
-  abs_tenant_id: string;
-}
+  interest_tags?: string[];
 
-export interface BackstageSettings {
-  enabled: boolean;
+  mentioned_user_ids?: string[];
 
-  join_ahead_time_seconds?: number;
-}
+  custom?: Record<string, any>;
 
-export interface BackstageSettingsRequest {
-  enabled?: boolean;
+  location?: ActivityLocation;
 
-  join_ahead_time_seconds?: number;
+  search_data?: Record<string, any>;
 }
 
-export interface BackstageSettingsResponse {
-  enabled: boolean;
+export interface AddActivityResponse {
+  duration: string;
 
-  join_ahead_time_seconds?: number;
+  activity: ActivityResponse;
 }
 
-export interface Ban {
-  created_at: Date;
+export interface AddBookmarkRequest {
+  folder_id?: string;
 
-  shadow: boolean;
+  user_id?: string;
 
-  expires?: Date;
+  custom?: Record<string, any>;
 
-  reason?: string;
+  new_folder?: AddFolderRequest;
 
-  channel?: Channel;
+  user?: UserRequest;
+}
 
-  created_by?: User;
+export interface AddBookmarkResponse {
+  duration: string;
 
-  target?: User;
+  bookmark: BookmarkResponse;
 }
 
-export interface BanActionRequest {
-  channel_ban_only?: boolean;
-
-  delete_messages?: 'soft' | 'pruning' | 'hard';
+export interface AddCommentReactionRequest {
+  type: string;
 
-  ip_ban?: boolean;
+  create_notification_activity?: boolean;
 
-  reason?: string;
+  user_id?: string;
 
-  shadow?: boolean;
+  custom?: Record<string, any>;
 
-  timeout?: number;
+  user?: UserRequest;
 }
 
-export interface BanOptions {
-  duration: number;
-
-  ip_ban: boolean;
+export interface AddCommentReactionResponse {
+  duration: string;
 
-  reason: string;
+  comment: CommentResponse;
 
-  shadow_ban: boolean;
+  reaction: FeedsReactionResponse;
 }
 
-export interface BanRequest {
-  target_user_id: string;
-
-  banned_by_id?: string;
-
-  channel_cid?: string;
-
-  delete_messages?: 'soft' | 'pruning' | 'hard';
-
-  ip_ban?: boolean;
+export interface AddCommentRequest {
+  comment: string;
 
-  reason?: string;
+  object_id: string;
 
-  shadow?: boolean;
+  object_type: string;
 
-  timeout?: number;
+  create_notification_activity?: boolean;
 
-  banned_by?: UserRequest;
-}
+  parent_id?: string;
 
-export interface BanResponse {
-  created_at: Date;
+  user_id?: string;
 
-  expires?: Date;
+  attachments?: Attachment[];
 
-  reason?: string;
+  mentioned_user_ids?: string[];
 
-  shadow?: boolean;
+  custom?: Record<string, any>;
 
-  banned_by?: UserResponse;
+  user?: UserRequest;
+}
 
-  channel?: ChannelResponse;
+export interface AddCommentResponse {
+  duration: string;
 
-  user?: UserResponse;
+  comment: CommentResponse;
 }
 
-export interface BlockContentOptions {
-  reason: string;
+export interface AddCommentsBatchRequest {
+  comments: AddCommentRequest[];
 }
 
-export interface BlockListConfig {
-  enabled: boolean;
-
-  rules: BlockListRule[];
+export interface AddCommentsBatchResponse {
+  duration: string;
 
-  async?: boolean;
+  comments: CommentResponse[];
 }
 
-export interface BlockListOptions {
-  behavior: 'flag' | 'block' | 'shadow_block';
+export interface AddFolderRequest {
+  name: string;
 
-  blocklist: string;
+  custom?: Record<string, any>;
 }
 
-export interface BlockListResponse {
-  name: string;
-
+export interface AddReactionRequest {
   type: string;
 
-  words: string[];
-
-  created_at?: Date;
+  create_notification_activity?: boolean;
 
-  id?: string;
+  user_id?: string;
 
-  team?: string;
+  custom?: Record<string, any>;
 
-  updated_at?: Date;
+  user?: UserRequest;
 }
 
-export interface BlockListRule {
-  action:
-    | 'flag'
-    | 'mask_flag'
-    | 'shadow'
-    | 'remove'
-    | 'bounce'
-    | 'bounce_flag'
-    | 'bounce_remove';
-
-  name: string;
-
-  team: string;
-}
+export interface AddReactionResponse {
+  duration: string;
 
-export interface BlockUserRequest {
-  user_id: string;
-}
+  activity: ActivityResponse;
 
-export interface BlockUserResponse {
-  duration: string;
+  reaction: FeedsReactionResponse;
 }
 
-export interface BlockUsersRequest {
-  blocked_user_id: string;
+export interface AggregatedActivityResponse {
+  activity_count: number;
 
-  user_id?: string;
+  created_at: Date;
 
-  user?: UserRequest;
-}
+  group: string;
 
-export interface BlockUsersResponse {
-  blocked_by_user_id: string;
+  score: number;
 
-  blocked_user_id: string;
+  updated_at: Date;
 
-  created_at: Date;
+  user_count: number;
 
-  duration: string;
+  activities: ActivityResponse[];
 }
 
-export interface BlockedUserEvent {
-  call_cid: string;
+export interface AggregationConfig {
+  format?: string;
+}
 
+export interface AnyEvent {
   created_at: Date;
 
-  user: UserResponse;
-
   type: string;
-
-  blocked_by_user?: UserResponse;
 }
 
-export interface BlockedUserResponse {
-  blocked_user_id: string;
+export interface AppResponseFields {
+  async_url_enrich_enabled: boolean;
 
-  created_at: Date;
+  auto_translation_enabled: boolean;
 
-  user_id: string;
+  campaign_enabled: boolean;
 
-  blocked_user: UserResponse;
+  cdn_expiration_seconds: number;
 
-  user: UserResponse;
-}
+  custom_action_handler_url: string;
 
-export interface BodyguardRule {
-  action:
-    | 'flag'
-    | 'shadow'
-    | 'remove'
-    | 'bounce'
-    | 'bounce_flag'
-    | 'bounce_remove';
+  disable_auth_checks: boolean;
 
-  label: string;
+  disable_permissions_checks: boolean;
 
-  severity_rules: BodyguardSeverityRule[];
-}
+  enforce_unique_usernames: string;
 
-export interface BodyguardSeverityRule {
-  action:
-    | 'flag'
-    | 'shadow'
-    | 'remove'
-    | 'bounce'
-    | 'bounce_flag'
-    | 'bounce_remove';
+  guest_user_creation_disabled: boolean;
 
-  severity: 'low' | 'medium' | 'high' | 'critical';
-}
+  image_moderation_enabled: boolean;
 
-export interface Bound {
-  inclusive: boolean;
+  moderation_enabled: boolean;
 
-  value: number;
-}
+  moderation_multitenant_blocklist_enabled: boolean;
 
-export interface BroadcastSettings {
-  enabled: boolean;
+  moderation_webhook_url: string;
 
-  hls?: HLSSettings;
+  multi_tenant_enabled: boolean;
 
-  rtmp?: RTMPSettings;
-}
+  name: string;
 
-export interface BroadcastSettingsRequest {
-  enabled?: boolean;
+  organization: string;
 
-  hls?: HLSSettingsRequest;
+  permission_version: string;
 
-  rtmp?: RTMPSettingsRequest;
-}
+  reminders_interval: number;
 
-export interface BroadcastSettingsResponse {
-  enabled: boolean;
+  sns_key: string;
 
-  hls: HLSSettingsResponse;
+  sns_secret: string;
 
-  rtmp: RTMPSettingsResponse;
-}
+  sns_topic_arn: string;
 
-export interface BrowserDataResponse {
-  name?: string;
+  sqs_key: string;
 
-  version?: string;
-}
+  sqs_secret: string;
 
-export interface BulkImageModerationRequest {
-  csv_file: string;
-}
-
-export interface BulkImageModerationResponse {
-  duration: string;
-
-  task_id: string;
-}
+  sqs_url: string;
 
-export interface Call {
-  app_pk: number;
+  suspended: boolean;
 
-  backstage: boolean;
+  suspended_explanation: string;
 
-  channel_cid: string;
+  use_hook_v2: boolean;
 
-  cid: string;
+  webhook_url: string;
 
-  created_at: Date;
+  event_hooks: EventHook[];
 
-  created_by_user_id: string;
+  user_search_disallowed_roles: string[];
 
-  current_session_id: string;
+  webhook_events: string[];
 
-  id: string;
+  call_types: Record<string, CallType>;
 
-  last_session_id: string;
+  channel_configs: Record<string, ChannelConfig>;
 
-  team: string;
+  file_upload_config: FileUploadConfig;
 
-  thumbnail_url: string;
+  grants: Record<string, string[]>;
 
-  type: string;
+  image_upload_config: FileUploadConfig;
 
-  updated_at: Date;
+  policies: Record<string, Policy[]>;
 
-  blocked_user_i_ds: string[];
+  push_notifications: PushNotificationFields;
 
-  blocked_users: User[];
+  before_message_send_hook_url?: string;
 
-  egresses: CallEgress[];
+  revoke_tokens_issued_before?: Date;
 
-  members: CallMember[];
+  allowed_flag_reasons?: string[];
 
-  custom: Record<string, any>;
+  geofences?: GeofenceResponse[];
 
-  deleted_at?: Date;
+  image_moderation_labels?: string[];
 
-  egress_updated_at?: Date;
+  datadog_info?: DataDogInfo;
 
-  ended_at?: Date;
+  moderation_dashboard_preferences?: ModerationDashboardPreferences;
+}
 
-  join_ahead_time_seconds?: number;
+export interface AsyncBulkImageModerationEvent {
+  created_at: Date;
 
-  last_heartbeat_at?: Date;
+  finished_at: Date;
 
-  member_count?: number;
+  started_at: Date;
 
-  starts_at?: Date;
+  task_id: string;
 
-  call_type?: CallType;
+  url: string;
 
-  created_by?: User;
+  custom: Record<string, any>;
 
-  member_lookup?: MemberLookup;
+  type: string;
 
-  session?: CallSession;
+  received_at?: Date;
+}
 
-  settings?: CallSettings;
+export interface AsyncExportChannelsEvent {
+  created_at: Date;
 
-  settings_overrides?: CallSettings;
-}
+  finished_at: Date;
 
-export interface CallAcceptedEvent {
-  call_cid: string;
+  started_at: Date;
 
-  created_at: Date;
+  task_id: string;
 
-  call: CallResponse;
+  url: string;
 
-  user: UserResponse;
+  custom: Record<string, any>;
 
   type: string;
-}
 
-export interface CallClosedCaption {
-  end_time: Date;
+  received_at?: Date;
+}
 
-  speaker_id: string;
+export interface AsyncExportErrorEvent {
+  created_at: Date;
 
-  start_time: Date;
+  error: string;
 
-  text: string;
+  finished_at: Date;
 
-  user: UserResponse;
-}
+  started_at: Date;
 
-export interface CallClosedCaptionsFailedEvent {
-  call_cid: string;
+  task_id: string;
 
-  created_at: Date;
+  custom: Record<string, any>;
 
   type: string;
-}
 
-export interface CallClosedCaptionsStartedEvent {
-  call_cid: string;
+  received_at?: Date;
+}
 
+export interface AsyncExportModerationLogsEvent {
   created_at: Date;
 
-  type: string;
-}
+  finished_at: Date;
 
-export interface CallClosedCaptionsStoppedEvent {
-  call_cid: string;
+  started_at: Date;
 
-  created_at: Date;
+  task_id: string;
+
+  url: string;
+
+  custom: Record<string, any>;
 
   type: string;
-}
 
-export interface CallCreatedEvent {
-  call_cid: string;
+  received_at?: Date;
+}
 
+export interface AsyncExportUsersEvent {
   created_at: Date;
 
-  members: MemberResponse[];
-
-  call: CallResponse;
+  finished_at: Date;
 
-  type: string;
-}
+  started_at: Date;
 
-export interface CallDeletedEvent {
-  call_cid: string;
+  task_id: string;
 
-  created_at: Date;
+  url: string;
 
-  call: CallResponse;
+  custom: Record<string, any>;
 
   type: string;
+
+  received_at?: Date;
 }
 
-export interface CallDurationReport {
-  histogram: ReportByHistogramBucket[];
+export interface AsyncModerationCallbackConfig {
+  mode?: 'CALLBACK_MODE_NONE' | 'CALLBACK_MODE_REST' | 'CALLBACK_MODE_TWIRP';
+
+  server_url?: string;
 }
 
-export interface CallDurationReportResponse {
-  daily: DailyAggregateCallDurationReportResponse[];
+export interface AsyncModerationConfiguration {
+  timeout_ms?: number;
+
+  callback?: AsyncModerationCallbackConfig;
 }
 
-export interface CallEgress {
-  app_pk: number;
+export interface Attachment {
+  custom: Record<string, any>;
 
-  call_id: string;
+  asset_url?: string;
 
-  call_type: string;
+  author_icon?: string;
 
-  egress_id: string;
+  author_link?: string;
 
-  egress_type: string;
+  author_name?: string;
 
-  instance_ip: string;
+  color?: string;
 
-  started_at: Date;
+  fallback?: string;
 
-  state: string;
+  footer?: string;
 
-  updated_at: Date;
+  footer_icon?: string;
 
-  stopped_at?: Date;
+  image_url?: string;
 
-  config?: EgressTaskConfig;
-}
+  og_scrape_url?: string;
 
-export interface CallEndedEvent {
-  call_cid: string;
+  original_height?: number;
 
-  created_at: Date;
+  original_width?: number;
 
-  call: CallResponse;
+  pretext?: string;
 
-  type: string;
+  text?: string;
 
-  reason?: string;
+  thumb_url?: string;
 
-  user?: UserResponse;
-}
+  title?: string;
 
-export interface CallFrameRecordingFailedEvent {
-  call_cid: string;
+  title_link?: string;
 
-  created_at: Date;
+  type?: string;
 
-  egress_id: string;
+  actions?: Action[];
 
-  call: CallResponse;
+  fields?: Field[];
 
-  type: string;
+  giphy?: Images;
 }
 
-export interface CallFrameRecordingFrameReadyEvent {
-  call_cid: string;
+export interface AudioSettings {
+  access_request_enabled: boolean;
 
-  captured_at: Date;
+  default_device: 'speaker' | 'earpiece';
 
-  created_at: Date;
+  mic_default_on: boolean;
 
-  egress_id: string;
+  opus_dtx_enabled: boolean;
 
-  session_id: string;
+  redundant_coding_enabled: boolean;
 
-  track_type: string;
+  speaker_default_on: boolean;
 
-  url: string;
+  noise_cancellation?: NoiseCancellationSettings;
+}
 
-  users: Record<string, UserResponse>;
+export interface AudioSettingsRequest {
+  default_device: 'speaker' | 'earpiece';
 
-  type: string;
-}
+  access_request_enabled?: boolean;
 
-export interface CallFrameRecordingStartedEvent {
-  call_cid: string;
+  mic_default_on?: boolean;
 
-  created_at: Date;
+  opus_dtx_enabled?: boolean;
 
-  egress_id: string;
+  redundant_coding_enabled?: boolean;
 
-  call: CallResponse;
+  speaker_default_on?: boolean;
 
-  type: string;
+  noise_cancellation?: NoiseCancellationSettings;
 }
 
-export interface CallFrameRecordingStoppedEvent {
-  call_cid: string;
+export interface AudioSettingsResponse {
+  access_request_enabled: boolean;
 
-  created_at: Date;
+  default_device: 'speaker' | 'earpiece';
 
-  egress_id: string;
+  mic_default_on: boolean;
 
-  call: CallResponse;
+  opus_dtx_enabled: boolean;
 
-  type: string;
-}
+  redundant_coding_enabled: boolean;
+
+  speaker_default_on: boolean;
+
+  noise_cancellation?: NoiseCancellationSettings;
+}
+
+export interface AutomodDetails {
+  action?: string;
+
+  original_message_type?: string;
+
+  image_labels?: string[];
+
+  message_details?: FlagMessageDetails;
+
+  result?: MessageModerationResult;
+}
+
+export interface AutomodPlatformCircumventionConfig {
+  enabled: boolean;
+
+  rules: AutomodRule[];
+
+  async?: boolean;
+}
+
+export interface AutomodRule {
+  action:
+    | 'flag'
+    | 'shadow'
+    | 'remove'
+    | 'bounce'
+    | 'bounce_flag'
+    | 'bounce_remove';
+
+  label: string;
+
+  threshold: number;
+}
+
+export interface AutomodSemanticFiltersConfig {
+  enabled: boolean;
+
+  rules: AutomodSemanticFiltersRule[];
+
+  async?: boolean;
+}
+
+export interface AutomodSemanticFiltersRule {
+  action: 'flag' | 'shadow' | 'remove';
+
+  name: string;
+
+  threshold: number;
+}
+
+export interface AutomodToxicityConfig {
+  enabled: boolean;
+
+  rules: AutomodRule[];
+
+  async?: boolean;
+}
+
+export interface AzureRequest {
+  abs_account_name: string;
+
+  abs_client_id: string;
+
+  abs_client_secret: string;
+
+  abs_tenant_id: string;
+}
+
+export interface BackstageSettings {
+  enabled: boolean;
+
+  join_ahead_time_seconds?: number;
+}
+
+export interface BackstageSettingsRequest {
+  enabled?: boolean;
+
+  join_ahead_time_seconds?: number;
+}
+
+export interface BackstageSettingsResponse {
+  enabled: boolean;
+
+  join_ahead_time_seconds?: number;
+}
+
+export interface Ban {
+  created_at: Date;
+
+  shadow: boolean;
+
+  expires?: Date;
+
+  reason?: string;
+
+  channel?: Channel;
+
+  created_by?: User;
+
+  target?: User;
+}
+
+export interface BanActionRequest {
+  channel_ban_only?: boolean;
+
+  delete_messages?: 'soft' | 'pruning' | 'hard';
+
+  ip_ban?: boolean;
+
+  reason?: string;
+
+  shadow?: boolean;
+
+  timeout?: number;
+}
+
+export interface BanOptions {
+  duration: number;
+
+  ip_ban: boolean;
+
+  reason: string;
+
+  shadow_ban: boolean;
+}
+
+export interface BanRequest {
+  target_user_id: string;
+
+  banned_by_id?: string;
+
+  channel_cid?: string;
+
+  delete_messages?: 'soft' | 'pruning' | 'hard';
+
+  ip_ban?: boolean;
+
+  reason?: string;
+
+  shadow?: boolean;
+
+  timeout?: number;
+
+  banned_by?: UserRequest;
+}
+
+export interface BanResponse {
+  created_at: Date;
+
+  expires?: Date;
+
+  reason?: string;
+
+  shadow?: boolean;
+
+  banned_by?: UserResponse;
+
+  channel?: ChannelResponse;
+
+  user?: UserResponse;
+}
+
+export interface BlockContentOptions {
+  reason: string;
+}
+
+export interface BlockListConfig {
+  enabled: boolean;
+
+  rules: BlockListRule[];
+
+  async?: boolean;
+}
+
+export interface BlockListOptions {
+  behavior: 'flag' | 'block' | 'shadow_block';
+
+  blocklist: string;
+}
+
+export interface BlockListResponse {
+  name: string;
+
+  type: string;
+
+  words: string[];
+
+  created_at?: Date;
+
+  id?: string;
+
+  team?: string;
+
+  updated_at?: Date;
+}
+
+export interface BlockListRule {
+  action:
+    | 'flag'
+    | 'mask_flag'
+    | 'shadow'
+    | 'remove'
+    | 'bounce'
+    | 'bounce_flag'
+    | 'bounce_remove';
+
+  name: string;
+
+  team: string;
+}
+
+export interface BlockUserRequest {
+  user_id: string;
+}
+
+export interface BlockUserResponse {
+  duration: string;
+}
+
+export interface BlockUsersRequest {
+  blocked_user_id: string;
+
+  user_id?: string;
+
+  user?: UserRequest;
+}
+
+export interface BlockUsersResponse {
+  blocked_by_user_id: string;
+
+  blocked_user_id: string;
+
+  created_at: Date;
+
+  duration: string;
+}
+
+export interface BlockedUserEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  user: UserResponse;
+
+  type: string;
+
+  blocked_by_user?: UserResponse;
+}
+
+export interface BlockedUserResponse {
+  blocked_user_id: string;
+
+  created_at: Date;
+
+  user_id: string;
+
+  blocked_user: UserResponse;
+
+  user: UserResponse;
+}
+
+export interface BodyguardRule {
+  action:
+    | 'flag'
+    | 'shadow'
+    | 'remove'
+    | 'bounce'
+    | 'bounce_flag'
+    | 'bounce_remove';
+
+  label: string;
+
+  severity_rules: BodyguardSeverityRule[];
+}
+
+export interface BodyguardSeverityRule {
+  action:
+    | 'flag'
+    | 'shadow'
+    | 'remove'
+    | 'bounce'
+    | 'bounce_flag'
+    | 'bounce_remove';
+
+  severity: 'low' | 'medium' | 'high' | 'critical';
+}
+
+export interface BookmarkAddedEvent {
+  created_at: Date;
+
+  bookmark: BookmarkResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
+export interface BookmarkDeletedEvent {
+  created_at: Date;
+
+  bookmark: BookmarkResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
+export interface BookmarkFolderDeletedEvent {
+  created_at: Date;
+
+  bookmark_folder: BookmarkFolderResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
+export interface BookmarkFolderResponse {
+  created_at: Date;
+
+  id: string;
+
+  name: string;
+
+  updated_at: Date;
+
+  custom?: Record<string, any>;
+}
+
+export interface BookmarkFolderUpdatedEvent {
+  created_at: Date;
+
+  bookmark_folder: BookmarkFolderResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
+export interface BookmarkResponse {
+  created_at: Date;
+
+  updated_at: Date;
+
+  activity: ActivityResponse;
+
+  user: UserResponse;
+
+  custom?: Record<string, any>;
+
+  folder?: BookmarkFolderResponse;
+}
+
+export interface BookmarkUpdatedEvent {
+  created_at: Date;
+
+  bookmark: BookmarkResponse;
+
+  custom: Record<string, any>;
+
+  type: string;
+
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
+}
+
+export interface Bound {
+  inclusive: boolean;
+
+  value: number;
+}
+
+export interface BroadcastSettings {
+  enabled: boolean;
+
+  hls?: HLSSettings;
+
+  rtmp?: RTMPSettings;
+}
+
+export interface BroadcastSettingsRequest {
+  enabled?: boolean;
+
+  hls?: HLSSettingsRequest;
+
+  rtmp?: RTMPSettingsRequest;
+}
+
+export interface BroadcastSettingsResponse {
+  enabled: boolean;
+
+  hls: HLSSettingsResponse;
+
+  rtmp: RTMPSettingsResponse;
+}
+
+export interface BrowserDataResponse {
+  name?: string;
+
+  version?: string;
+}
+
+export interface BulkImageModerationRequest {
+  csv_file: string;
+}
+
+export interface BulkImageModerationResponse {
+  duration: string;
+
+  task_id: string;
+}
+
+export interface Call {
+  app_pk: number;
+
+  backstage: boolean;
+
+  channel_cid: string;
+
+  cid: string;
+
+  created_at: Date;
+
+  created_by_user_id: string;
+
+  current_session_id: string;
+
+  id: string;
+
+  last_session_id: string;
+
+  team: string;
+
+  thumbnail_url: string;
+
+  type: string;
+
+  updated_at: Date;
+
+  blocked_user_i_ds: string[];
+
+  blocked_users: User[];
+
+  egresses: CallEgress[];
+
+  members: CallMember[];
+
+  custom: Record<string, any>;
+
+  deleted_at?: Date;
+
+  egress_updated_at?: Date;
+
+  ended_at?: Date;
+
+  join_ahead_time_seconds?: number;
+
+  last_heartbeat_at?: Date;
+
+  member_count?: number;
+
+  starts_at?: Date;
+
+  call_type?: CallType;
+
+  created_by?: User;
+
+  member_lookup?: MemberLookup;
+
+  session?: CallSession;
+
+  settings?: CallSettings;
+
+  settings_overrides?: CallSettings;
+}
+
+export interface CallAcceptedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  call: CallResponse;
+
+  user: UserResponse;
+
+  type: string;
+}
+
+export interface CallClosedCaption {
+  end_time: Date;
+
+  speaker_id: string;
+
+  start_time: Date;
+
+  text: string;
+
+  user: UserResponse;
+}
+
+export interface CallClosedCaptionsFailedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  type: string;
+}
+
+export interface CallClosedCaptionsStartedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  type: string;
+}
+
+export interface CallClosedCaptionsStoppedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  type: string;
+}
+
+export interface CallCreatedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallDeletedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallDurationReport {
+  histogram: ReportByHistogramBucket[];
+}
+
+export interface CallDurationReportResponse {
+  daily: DailyAggregateCallDurationReportResponse[];
+}
+
+export interface CallEgress {
+  app_pk: number;
+
+  call_id: string;
+
+  call_type: string;
+
+  egress_id: string;
+
+  egress_type: string;
+
+  instance_ip: string;
+
+  started_at: Date;
+
+  state: string;
+
+  updated_at: Date;
+
+  stopped_at?: Date;
+
+  config?: EgressTaskConfig;
+}
+
+export interface CallEndedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  call: CallResponse;
+
+  type: string;
+
+  reason?: string;
+
+  user?: UserResponse;
+}
+
+export interface CallFrameRecordingFailedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallFrameRecordingFrameReadyEvent {
+  call_cid: string;
+
+  captured_at: Date;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  session_id: string;
+
+  track_type: string;
+
+  url: string;
+
+  users: Record<string, UserResponse>;
+
+  type: string;
+}
+
+export interface CallFrameRecordingStartedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallFrameRecordingStoppedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  call: CallResponse;
+
+  type: string;
+}
 
 export interface CallHLSBroadcastingFailedEvent {
   call_cid: string;
@@ -1097,237 +1713,669 @@ export interface CallHLSBroadcastingFailedEvent {
   type: string;
 }
 
-export interface CallHLSBroadcastingStartedEvent {
+export interface CallHLSBroadcastingStartedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  hls_playlist_url: string;
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallHLSBroadcastingStoppedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  type: string;
+}
+
+export interface CallIngressResponse {
+  rtmp: RTMPIngress;
+}
+
+export interface CallLiveStartedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallMember {
+  created_at: Date;
+
+  role: string;
+
+  updated_at: Date;
+
+  user_id: string;
+
+  custom: Record<string, any>;
+
+  deleted_at?: Date;
+
+  user?: User;
+}
+
+export interface CallMemberAddedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallMemberRemovedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  members: string[];
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallMemberUpdatedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  type: string;
+}
+
+export interface CallMemberUpdatedPermissionEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  capabilities_by_role: Record<string, string[]>;
+
+  type: string;
+}
+
+export interface CallMissedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  notify_user: boolean;
+
+  session_id: string;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  user: UserResponse;
+
+  type: string;
+}
+
+export interface CallModerationBlurEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  user_id: string;
+
+  custom: Record<string, any>;
+
+  type: string;
+}
+
+export interface CallModerationWarningEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  message: string;
+
+  user_id: string;
+
+  custom: Record<string, any>;
+
+  type: string;
+}
+
+export interface CallNotificationEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  session_id: string;
+
+  members: MemberResponse[];
+
+  call: CallResponse;
+
+  user: UserResponse;
+
+  type: string;
+}
+
+export interface CallParticipant {
+  banned: boolean;
+
+  id: string;
+
+  joined_at: Date;
+
+  online: boolean;
+
+  role: string;
+
+  user_session_id: string;
+
+  custom: Record<string, any>;
+
+  teams_role: Record<string, string>;
+
+  ban_expires?: Date;
+
+  created_at?: Date;
+
+  deactivated_at?: Date;
+
+  deleted_at?: Date;
+
+  invisible?: boolean;
+
+  language?: string;
+
+  last_active?: Date;
+
+  last_engaged_at?: Date;
+
+  revoke_tokens_issued_before?: Date;
+
+  updated_at?: Date;
+
+  teams?: string[];
+
+  privacy_settings?: PrivacySettings;
+}
+
+export interface CallParticipantCountReport {
+  histogram: ReportByHistogramBucket[];
+}
+
+export interface CallParticipantCountReportResponse {
+  daily: DailyAggregateCallParticipantCountReportResponse[];
+}
+
+export interface CallParticipantResponse {
+  joined_at: Date;
+
+  role: string;
+
+  user_session_id: string;
+
+  user: UserResponse;
+}
+
+export interface CallReactionEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  reaction: ReactionResponse;
+
+  type: string;
+}
+
+export interface CallRecording {
+  end_time: Date;
+
+  filename: string;
+
+  session_id: string;
+
+  start_time: Date;
+
+  url: string;
+}
+
+export interface CallRecordingFailedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  type: string;
+}
+
+export interface CallRecordingReadyEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  call_recording: CallRecording;
+
+  type: string;
+}
+
+export interface CallRecordingStartedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  egress_id: string;
+
+  type: string;
+}
+
+export interface CallRecordingStoppedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  hls_playlist_url: string;
-
-  call: CallResponse;
+  egress_id: string;
 
   type: string;
 }
 
-export interface CallHLSBroadcastingStoppedEvent {
+export interface CallRejectedEvent {
   call_cid: string;
 
   created_at: Date;
 
+  call: CallResponse;
+
+  user: UserResponse;
+
   type: string;
+
+  reason?: string;
 }
 
-export interface CallIngressResponse {
-  rtmp: RTMPIngress;
+export interface CallReportResponse {
+  score: number;
+
+  ended_at?: Date;
+
+  started_at?: Date;
 }
 
-export interface CallLiveStartedEvent {
-  call_cid: string;
+export interface CallRequest {
+  channel_cid?: string;
 
-  created_at: Date;
+  created_by_id?: string;
 
-  call: CallResponse;
+  starts_at?: Date;
 
-  type: string;
+  team?: string;
+
+  video?: boolean;
+
+  members?: MemberRequest[];
+
+  created_by?: UserRequest;
+
+  custom?: Record<string, any>;
+
+  settings_override?: CallSettingsRequest;
 }
 
-export interface CallMember {
+export interface CallResponse {
+  backstage: boolean;
+
+  captioning: boolean;
+
+  cid: string;
+
   created_at: Date;
 
-  role: string;
+  current_session_id: string;
+
+  id: string;
+
+  recording: boolean;
+
+  transcribing: boolean;
+
+  type: string;
 
   updated_at: Date;
 
-  user_id: string;
+  blocked_user_ids: string[];
+
+  created_by: UserResponse;
 
   custom: Record<string, any>;
 
-  deleted_at?: Date;
+  egress: EgressResponse;
 
-  user?: User;
+  ingress: CallIngressResponse;
+
+  settings: CallSettingsResponse;
+
+  channel_cid?: string;
+
+  ended_at?: Date;
+
+  join_ahead_time_seconds?: number;
+
+  starts_at?: Date;
+
+  team?: string;
+
+  session?: CallSessionResponse;
+
+  thumbnails?: ThumbnailResponse;
 }
 
-export interface CallMemberAddedEvent {
+export interface CallRingEvent {
   call_cid: string;
 
   created_at: Date;
 
+  session_id: string;
+
+  video: boolean;
+
   members: MemberResponse[];
 
   call: CallResponse;
 
+  user: UserResponse;
+
   type: string;
 }
 
-export interface CallMemberRemovedEvent {
+export interface CallRtmpBroadcastFailedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  members: string[];
-
-  call: CallResponse;
+  name: string;
 
   type: string;
 }
 
-export interface CallMemberUpdatedEvent {
+export interface CallRtmpBroadcastStartedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  members: MemberResponse[];
-
-  call: CallResponse;
+  name: string;
 
   type: string;
 }
 
-export interface CallMemberUpdatedPermissionEvent {
+export interface CallRtmpBroadcastStoppedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  members: MemberResponse[];
+  name: string;
 
-  call: CallResponse;
+  type: string;
+}
 
-  capabilities_by_role: Record<string, string[]>;
+export interface CallSession {
+  anonymous_participant_count: number;
 
-  type: string;
+  app_pk: number;
+
+  call_id: string;
+
+  call_type: string;
+
+  created_at: Date;
+
+  session_id: string;
+
+  active_sf_us: SFUIDLastSeen[];
+
+  participants: CallParticipant[];
+
+  sfui_ds: string[];
+
+  accepted_by: Record<string, Date>;
+
+  missed_by: Record<string, Date>;
+
+  participants_count_by_role: Record<string, number>;
+
+  rejected_by: Record<string, Date>;
+
+  user_permission_overrides: Record<string, Record<string, boolean>>;
+
+  deleted_at?: Date;
+
+  ended_at?: Date;
+
+  live_ended_at?: Date;
+
+  live_started_at?: Date;
+
+  ring_at?: Date;
+
+  started_at?: Date;
+
+  timer_ends_at?: Date;
 }
 
-export interface CallMissedEvent {
+export interface CallSessionEndedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  notify_user: boolean;
-
   session_id: string;
 
-  members: MemberResponse[];
-
   call: CallResponse;
 
-  user: UserResponse;
-
   type: string;
 }
 
-export interface CallModerationBlurEvent {
+export interface CallSessionParticipantJoinedEvent {
   call_cid: string;
 
   created_at: Date;
 
-  user_id: string;
+  session_id: string;
 
-  custom: Record<string, any>;
+  participant: CallParticipantResponse;
 
   type: string;
 }
 
-export interface CallModerationWarningEvent {
+export interface CallSessionParticipantLeftEvent {
   call_cid: string;
 
   created_at: Date;
 
-  message: string;
+  duration_seconds: number;
 
-  user_id: string;
+  session_id: string;
 
-  custom: Record<string, any>;
+  participant: CallParticipantResponse;
 
   type: string;
 }
 
-export interface CallNotificationEvent {
+export interface CallSessionResponse {
+  anonymous_participant_count: number;
+
+  id: string;
+
+  participants: CallParticipantResponse[];
+
+  accepted_by: Record<string, Date>;
+
+  missed_by: Record<string, Date>;
+
+  participants_count_by_role: Record<string, number>;
+
+  rejected_by: Record<string, Date>;
+
+  ended_at?: Date;
+
+  live_ended_at?: Date;
+
+  live_started_at?: Date;
+
+  started_at?: Date;
+
+  timer_ends_at?: Date;
+}
+
+export interface CallSessionStartedEvent {
   call_cid: string;
 
   created_at: Date;
 
   session_id: string;
 
-  members: MemberResponse[];
-
   call: CallResponse;
 
-  user: UserResponse;
-
   type: string;
 }
 
-export interface CallParticipant {
-  banned: boolean;
+export interface CallSettings {
+  audio?: AudioSettings;
 
-  id: string;
+  backstage?: BackstageSettings;
 
-  joined_at: Date;
+  broadcasting?: BroadcastSettings;
+
+  frame_recording?: FrameRecordSettings;
+
+  geofencing?: GeofenceSettings;
+
+  limits?: LimitsSettings;
+
+  recording?: RecordSettings;
+
+  ring?: RingSettings;
+
+  screensharing?: ScreensharingSettings;
+
+  session?: SessionSettings;
+
+  thumbnails?: ThumbnailsSettings;
+
+  transcription?: TranscriptionSettings;
+
+  video?: VideoSettings;
+}
+
+export interface CallSettingsRequest {
+  audio?: AudioSettingsRequest;
+
+  backstage?: BackstageSettingsRequest;
+
+  broadcasting?: BroadcastSettingsRequest;
+
+  frame_recording?: FrameRecordingSettingsRequest;
+
+  geofencing?: GeofenceSettingsRequest;
+
+  limits?: LimitsSettingsRequest;
+
+  recording?: RecordSettingsRequest;
+
+  ring?: RingSettingsRequest;
+
+  screensharing?: ScreensharingSettingsRequest;
 
-  online: boolean;
+  session?: SessionSettingsRequest;
 
-  role: string;
+  thumbnails?: ThumbnailsSettingsRequest;
 
-  user_session_id: string;
+  transcription?: TranscriptionSettingsRequest;
 
-  custom: Record<string, any>;
+  video?: VideoSettingsRequest;
+}
 
-  teams_role: Record<string, string>;
+export interface CallSettingsResponse {
+  audio: AudioSettingsResponse;
 
-  ban_expires?: Date;
+  backstage: BackstageSettingsResponse;
 
-  created_at?: Date;
+  broadcasting: BroadcastSettingsResponse;
 
-  deactivated_at?: Date;
+  frame_recording: FrameRecordingSettingsResponse;
 
-  deleted_at?: Date;
+  geofencing: GeofenceSettingsResponse;
 
-  invisible?: boolean;
+  limits: LimitsSettingsResponse;
 
-  language?: string;
+  recording: RecordSettingsResponse;
 
-  last_active?: Date;
+  ring: RingSettingsResponse;
 
-  last_engaged_at?: Date;
+  screensharing: ScreensharingSettingsResponse;
 
-  revoke_tokens_issued_before?: Date;
+  session: SessionSettingsResponse;
 
-  updated_at?: Date;
+  thumbnails: ThumbnailsSettingsResponse;
 
-  teams?: string[];
+  transcription: TranscriptionSettingsResponse;
 
-  privacy_settings?: PrivacySettings;
+  video: VideoSettingsResponse;
 }
 
-export interface CallParticipantCountReport {
-  histogram: ReportByHistogramBucket[];
-}
+export interface CallStateResponseFields {
+  members: MemberResponse[];
 
-export interface CallParticipantCountReportResponse {
-  daily: DailyAggregateCallParticipantCountReportResponse[];
+  own_capabilities: OwnCapability[];
+
+  call: CallResponse;
 }
 
-export interface CallParticipantResponse {
-  joined_at: Date;
+export interface CallStatsReportReadyEvent {
+  call_cid: string;
 
-  role: string;
+  created_at: Date;
 
-  user_session_id: string;
+  session_id: string;
 
-  user: UserResponse;
+  type: string;
 }
 
-export interface CallReactionEvent {
+export interface CallStatsReportSummaryResponse {
   call_cid: string;
 
-  created_at: Date;
+  call_duration_seconds: number;
 
-  reaction: ReactionResponse;
+  call_session_id: string;
 
-  type: string;
+  call_status: string;
+
+  first_stats_time: Date;
+
+  created_at?: Date;
+
+  min_user_rating?: number;
+
+  quality_score?: number;
 }
 
-export interface CallRecording {
+export interface CallTranscription {
   end_time: Date;
 
   filename: string;
@@ -1339,7 +2387,7 @@ export interface CallRecording {
   url: string;
 }
 
-export interface CallRecordingFailedEvent {
+export interface CallTranscriptionFailedEvent {
   call_cid: string;
 
   created_at: Date;
@@ -1347,21 +2395,23 @@ export interface CallRecordingFailedEvent {
   egress_id: string;
 
   type: string;
+
+  error?: string;
 }
 
-export interface CallRecordingReadyEvent {
+export interface CallTranscriptionReadyEvent {
   call_cid: string;
 
   created_at: Date;
 
   egress_id: string;
 
-  call_recording: CallRecording;
+  call_transcription: CallTranscription;
 
   type: string;
 }
 
-export interface CallRecordingStartedEvent {
+export interface CallTranscriptionStartedEvent {
   call_cid: string;
 
   created_at: Date;
@@ -1371,7 +2421,7 @@ export interface CallRecordingStartedEvent {
   type: string;
 }
 
-export interface CallRecordingStoppedEvent {
+export interface CallTranscriptionStoppedEvent {
   call_cid: string;
 
   created_at: Date;
@@ -1381,693 +2431,792 @@ export interface CallRecordingStoppedEvent {
   type: string;
 }
 
-export interface CallRejectedEvent {
+export interface CallType {
+  app_pk: number;
+
+  created_at: Date;
+
+  external_storage: string;
+
+  name: string;
+
+  pk: number;
+
+  updated_at: Date;
+
+  notification_settings?: NotificationSettings;
+
+  settings?: CallSettings;
+}
+
+export interface CallTypeResponse {
+  created_at: Date;
+
+  name: string;
+
+  updated_at: Date;
+
+  grants: Record<string, string[]>;
+
+  notification_settings: NotificationSettings;
+
+  settings: CallSettingsResponse;
+
+  external_storage?: string;
+}
+
+export interface CallUpdatedEvent {
   call_cid: string;
 
   created_at: Date;
 
   call: CallResponse;
 
+  capabilities_by_role: Record<string, string[]>;
+
+  type: string;
+}
+
+export interface CallUserFeedbackSubmittedEvent {
+  call_cid: string;
+
+  created_at: Date;
+
+  rating: number;
+
+  session_id: string;
+
   user: UserResponse;
 
   type: string;
 
   reason?: string;
+
+  sdk?: string;
+
+  sdk_version?: string;
+
+  custom?: Record<string, any>;
 }
 
-export interface CallReportResponse {
-  score: number;
+export interface CallUserMutedEvent {
+  call_cid: string;
 
-  ended_at?: Date;
+  created_at: Date;
 
-  started_at?: Date;
+  from_user_id: string;
+
+  muted_user_ids: string[];
+
+  type: string;
 }
 
-export interface CallRequest {
-  channel_cid?: string;
+export interface CallsPerDayReport {
+  count: number;
+}
 
-  created_by_id?: string;
+export interface CallsPerDayReportResponse {
+  daily: DailyAggregateCallsPerDayReportResponse[];
+}
 
-  starts_at?: Date;
+export interface CampaignChannelTemplate {
+  type: string;
+
+  custom: Record<string, any>;
+
+  id?: string;
 
   team?: string;
 
-  video?: boolean;
+  members?: string[];
+}
 
-  members?: MemberRequest[];
+export interface CampaignCompletedEvent {
+  created_at: Date;
 
-  created_by?: UserRequest;
+  custom: Record<string, any>;
 
-  custom?: Record<string, any>;
+  type: string;
 
-  settings_override?: CallSettingsRequest;
+  received_at?: Date;
+
+  campaign?: CampaignResponse;
 }
 
-export interface CallResponse {
-  backstage: boolean;
+export interface CampaignMessageTemplate {
+  poll_id: string;
 
-  captioning: boolean;
+  text: string;
 
-  cid: string;
+  attachments: Attachment[];
+
+  custom: Record<string, any>;
+}
+
+export interface CampaignResponse {
+  create_channels: boolean;
 
   created_at: Date;
 
-  current_session_id: string;
+  description: string;
 
   id: string;
 
-  recording: boolean;
+  name: string;
 
-  transcribing: boolean;
+  sender_id: string;
 
-  type: string;
+  sender_mode: string;
 
-  updated_at: Date;
+  show_channels: boolean;
 
-  blocked_user_ids: string[];
+  skip_push: boolean;
 
-  created_by: UserResponse;
+  skip_webhook: boolean;
 
-  custom: Record<string, any>;
+  status: string;
 
-  egress: EgressResponse;
+  updated_at: Date;
 
-  ingress: CallIngressResponse;
+  segment_ids: string[];
 
-  settings: CallSettingsResponse;
+  segments: Segment[];
 
-  channel_cid?: string;
+  user_ids: string[];
 
-  ended_at?: Date;
+  users: UserResponse[];
 
-  join_ahead_time_seconds?: number;
+  stats: CampaignStatsResponse;
 
-  starts_at?: Date;
+  scheduled_for?: Date;
 
-  team?: string;
+  stop_at?: Date;
 
-  session?: CallSessionResponse;
+  channel_template?: CampaignChannelTemplate;
 
-  thumbnails?: ThumbnailResponse;
-}
+  message_template?: CampaignMessageTemplate;
 
-export interface CallRingEvent {
-  call_cid: string;
+  sender?: UserResponse;
+}
 
+export interface CampaignStartedEvent {
   created_at: Date;
 
-  session_id: string;
+  custom: Record<string, any>;
 
-  video: boolean;
+  type: string;
 
-  members: MemberResponse[];
+  received_at?: Date;
 
-  call: CallResponse;
+  campaign?: CampaignResponse;
+}
 
-  user: UserResponse;
+export interface CampaignStatsResponse {
+  progress: number;
 
-  type: string;
-}
+  stats_channels_created: number;
+
+  stats_completed_at: Date;
 
-export interface CallRtmpBroadcastFailedEvent {
-  call_cid: string;
+  stats_messages_sent: number;
 
-  created_at: Date;
+  stats_started_at: Date;
 
-  name: string;
+  stats_users_read: number;
 
-  type: string;
+  stats_users_sent: number;
 }
 
-export interface CallRtmpBroadcastStartedEvent {
-  call_cid: string;
-
-  created_at: Date;
+export interface CastPollVoteRequest {
+  user_id?: string;
 
-  name: string;
+  user?: UserRequest;
 
-  type: string;
+  vote?: VoteData;
 }
 
-export interface CallRtmpBroadcastStoppedEvent {
-  call_cid: string;
+export interface Channel {
+  auto_translation_language: string;
 
-  created_at: Date;
+  cid: string;
 
-  name: string;
+  created_at: Date;
 
-  type: string;
-}
+  disabled: boolean;
 
-export interface CallSession {
-  anonymous_participant_count: number;
+  frozen: boolean;
 
-  app_pk: number;
+  id: string;
 
-  call_id: string;
+  type: string;
 
-  call_type: string;
+  updated_at: Date;
 
-  created_at: Date;
+  custom: Record<string, any>;
 
-  session_id: string;
+  auto_translation_enabled?: boolean;
 
-  active_sf_us: SFUIDLastSeen[];
+  cooldown?: number;
 
-  participants: CallParticipant[];
+  deleted_at?: Date;
 
-  sfui_ds: string[];
+  last_campaigns?: string;
 
-  accepted_by: Record<string, Date>;
+  last_message_at?: Date;
 
-  missed_by: Record<string, Date>;
+  member_count?: number;
 
-  participants_count_by_role: Record<string, number>;
+  team?: string;
 
-  rejected_by: Record<string, Date>;
+  active_live_locations?: SharedLocation[];
 
-  user_permission_overrides: Record<string, Record<string, boolean>>;
+  invites?: ChannelMember[];
 
-  deleted_at?: Date;
+  members?: ChannelMember[];
 
-  ended_at?: Date;
+  config?: ChannelConfig;
 
-  live_ended_at?: Date;
+  config_overrides?: ConfigOverrides;
 
-  live_started_at?: Date;
+  created_by?: User;
 
-  ring_at?: Date;
+  truncated_by?: User;
+}
 
-  started_at?: Date;
+export interface ChannelConfig {
+  automod: 'disabled' | 'simple' | 'AI';
 
-  timer_ends_at?: Date;
-}
+  automod_behavior: 'flag' | 'block' | 'shadow_block';
 
-export interface CallSessionEndedEvent {
-  call_cid: string;
+  connect_events: boolean;
 
   created_at: Date;
 
-  session_id: string;
+  custom_events: boolean;
 
-  call: CallResponse;
+  mark_messages_pending: boolean;
 
-  type: string;
-}
+  max_message_length: number;
 
-export interface CallSessionParticipantJoinedEvent {
-  call_cid: string;
+  mutes: boolean;
 
-  created_at: Date;
+  name: string;
 
-  session_id: string;
+  polls: boolean;
 
-  participant: CallParticipantResponse;
+  push_notifications: boolean;
 
-  type: string;
-}
+  quotes: boolean;
 
-export interface CallSessionParticipantLeftEvent {
-  call_cid: string;
+  reactions: boolean;
 
-  created_at: Date;
+  read_events: boolean;
 
-  duration_seconds: number;
+  reminders: boolean;
 
-  session_id: string;
+  replies: boolean;
 
-  participant: CallParticipantResponse;
+  search: boolean;
 
-  type: string;
-}
+  shared_locations: boolean;
 
-export interface CallSessionResponse {
-  anonymous_participant_count: number;
+  skip_last_msg_update_for_system_msgs: boolean;
 
-  id: string;
+  typing_events: boolean;
 
-  participants: CallParticipantResponse[];
+  updated_at: Date;
 
-  accepted_by: Record<string, Date>;
+  uploads: boolean;
 
-  missed_by: Record<string, Date>;
+  url_enrichment: boolean;
 
-  participants_count_by_role: Record<string, number>;
+  user_message_reminders: boolean;
 
-  rejected_by: Record<string, Date>;
+  commands: string[];
 
-  ended_at?: Date;
+  blocklist?: string;
 
-  live_ended_at?: Date;
+  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
 
-  live_started_at?: Date;
+  partition_size?: number;
 
-  started_at?: Date;
+  partition_ttl?: number;
 
-  timer_ends_at?: Date;
+  allowed_flag_reasons?: string[];
+
+  blocklists?: BlockListOptions[];
+
+  automod_thresholds?: Thresholds;
 }
 
-export interface CallSessionStartedEvent {
-  call_cid: string;
+export interface ChannelConfigWithInfo {
+  automod: 'disabled' | 'simple' | 'AI';
+
+  automod_behavior: 'flag' | 'block' | 'shadow_block';
+
+  connect_events: boolean;
 
   created_at: Date;
 
-  session_id: string;
+  custom_events: boolean;
 
-  call: CallResponse;
+  mark_messages_pending: boolean;
 
-  type: string;
-}
+  max_message_length: number;
 
-export interface CallSettings {
-  audio?: AudioSettings;
+  mutes: boolean;
 
-  backstage?: BackstageSettings;
+  name: string;
 
-  broadcasting?: BroadcastSettings;
+  polls: boolean;
 
-  frame_recording?: FrameRecordSettings;
+  push_notifications: boolean;
 
-  geofencing?: GeofenceSettings;
+  quotes: boolean;
 
-  limits?: LimitsSettings;
+  reactions: boolean;
 
-  recording?: RecordSettings;
+  read_events: boolean;
 
-  ring?: RingSettings;
+  reminders: boolean;
 
-  screensharing?: ScreensharingSettings;
+  replies: boolean;
 
-  session?: SessionSettings;
+  search: boolean;
 
-  thumbnails?: ThumbnailsSettings;
+  shared_locations: boolean;
 
-  transcription?: TranscriptionSettings;
+  skip_last_msg_update_for_system_msgs: boolean;
 
-  video?: VideoSettings;
-}
+  typing_events: boolean;
 
-export interface CallSettingsRequest {
-  audio?: AudioSettingsRequest;
+  updated_at: Date;
 
-  backstage?: BackstageSettingsRequest;
+  uploads: boolean;
 
-  broadcasting?: BroadcastSettingsRequest;
+  url_enrichment: boolean;
 
-  frame_recording?: FrameRecordingSettingsRequest;
+  user_message_reminders: boolean;
 
-  geofencing?: GeofenceSettingsRequest;
+  commands: Command[];
 
-  limits?: LimitsSettingsRequest;
+  blocklist?: string;
 
-  recording?: RecordSettingsRequest;
+  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
 
-  ring?: RingSettingsRequest;
+  partition_size?: number;
 
-  screensharing?: ScreensharingSettingsRequest;
+  partition_ttl?: string;
 
-  session?: SessionSettingsRequest;
+  allowed_flag_reasons?: string[];
 
-  thumbnails?: ThumbnailsSettingsRequest;
+  blocklists?: BlockListOptions[];
 
-  transcription?: TranscriptionSettingsRequest;
+  automod_thresholds?: Thresholds;
 
-  video?: VideoSettingsRequest;
+  grants?: Record<string, string[]>;
 }
 
-export interface CallSettingsResponse {
-  audio: AudioSettingsResponse;
-
-  backstage: BackstageSettingsResponse;
+export interface ChannelCreatedEvent {
+  created_at: Date;
 
-  broadcasting: BroadcastSettingsResponse;
+  type: string;
+}
 
-  frame_recording: FrameRecordingSettingsResponse;
+export interface ChannelDeletedEvent {
+  channel_id: string;
 
-  geofencing: GeofenceSettingsResponse;
+  channel_member_count: number;
 
-  limits: LimitsSettingsResponse;
+  channel_type: string;
 
-  recording: RecordSettingsResponse;
+  cid: string;
 
-  ring: RingSettingsResponse;
+  created_at: Date;
 
-  screensharing: ScreensharingSettingsResponse;
+  type: string;
 
-  session: SessionSettingsResponse;
+  team?: string;
 
-  thumbnails: ThumbnailsSettingsResponse;
+  channel?: ChannelResponse;
+}
 
-  transcription: TranscriptionSettingsResponse;
+export interface ChannelExport {
+  cid?: string;
 
-  video: VideoSettingsResponse;
-}
+  id?: string;
 
-export interface CallStateResponseFields {
-  members: MemberResponse[];
+  messages_since?: Date;
 
-  own_capabilities: OwnCapability[];
+  messages_until?: Date;
 
-  call: CallResponse;
+  type?: string;
 }
 
-export interface CallStatsReportReadyEvent {
-  call_cid: string;
+export interface ChannelFrozenEvent {
+  channel_id: string;
+
+  channel_type: string;
+
+  cid: string;
 
   created_at: Date;
 
-  session_id: string;
-
   type: string;
 }
 
-export interface CallStatsReportSummaryResponse {
-  call_cid: string;
-
-  call_duration_seconds: number;
+export interface ChannelGetOrCreateRequest {
+  hide_for_creator?: boolean;
 
-  call_session_id: string;
+  state?: boolean;
 
-  call_status: string;
+  thread_unread_counts?: boolean;
 
-  first_stats_time: Date;
+  data?: ChannelInput;
 
-  created_at?: Date;
+  members?: PaginationParams;
 
-  min_user_rating?: number;
+  messages?: MessagePaginationParams;
 
-  quality_score?: number;
+  watchers?: PaginationParams;
 }
 
-export interface CallTranscription {
-  end_time: Date;
-
-  filename: string;
+export interface ChannelHiddenEvent {
+  channel_id: string;
 
-  session_id: string;
+  channel_member_count: number;
 
-  start_time: Date;
+  channel_type: string;
 
-  url: string;
-}
+  cid: string;
 
-export interface CallTranscriptionFailedEvent {
-  call_cid: string;
+  clear_history: boolean;
 
   created_at: Date;
 
-  egress_id: string;
-
   type: string;
 
-  error?: string;
-}
+  channel?: ChannelResponse;
 
-export interface CallTranscriptionReadyEvent {
-  call_cid: string;
+  user?: User;
+}
 
-  created_at: Date;
+export interface ChannelInput {
+  auto_translation_enabled?: boolean;
 
-  egress_id: string;
+  auto_translation_language?: string;
 
-  call_transcription: CallTranscription;
+  created_by_id?: string;
 
-  type: string;
-}
+  disabled?: boolean;
 
-export interface CallTranscriptionStartedEvent {
-  call_cid: string;
+  frozen?: boolean;
 
-  created_at: Date;
+  team?: string;
 
-  egress_id: string;
+  truncated_by_id?: string;
 
-  type: string;
-}
+  invites?: ChannelMember[];
 
-export interface CallTranscriptionStoppedEvent {
-  call_cid: string;
+  members?: ChannelMember[];
 
-  created_at: Date;
+  config_overrides?: ChannelConfig;
 
-  egress_id: string;
+  created_by?: UserRequest;
 
-  type: string;
+  custom?: Record<string, any>;
 }
 
-export interface CallType {
-  app_pk: number;
+export interface ChannelMember {
+  banned: boolean;
 
-  created_at: Date;
+  channel_role: string;
 
-  external_storage: string;
+  created_at: Date;
 
-  name: string;
+  notifications_muted: boolean;
 
-  pk: number;
+  shadow_banned: boolean;
 
   updated_at: Date;
 
-  notification_settings?: NotificationSettings;
-
-  settings?: CallSettings;
-}
+  custom: Record<string, any>;
 
-export interface CallTypeResponse {
-  created_at: Date;
+  archived_at?: Date;
 
-  name: string;
+  ban_expires?: Date;
 
-  updated_at: Date;
+  deleted_at?: Date;
 
-  grants: Record<string, string[]>;
+  invite_accepted_at?: Date;
 
-  notification_settings: NotificationSettings;
+  invite_rejected_at?: Date;
 
-  settings: CallSettingsResponse;
+  invited?: boolean;
 
-  external_storage?: string;
-}
+  is_moderator?: boolean;
 
-export interface CallUpdatedEvent {
-  call_cid: string;
+  pinned_at?: Date;
 
-  created_at: Date;
+  role?: 'member' | 'moderator' | 'admin' | 'owner';
 
-  call: CallResponse;
+  status?: string;
 
-  capabilities_by_role: Record<string, string[]>;
+  user_id?: string;
 
-  type: string;
+  user?: UserResponse;
 }
 
-export interface CallUserFeedbackSubmittedEvent {
-  call_cid: string;
+export interface ChannelMemberResponse {
+  banned: boolean;
+
+  channel_role: string;
 
   created_at: Date;
 
-  rating: number;
+  notifications_muted: boolean;
 
-  session_id: string;
+  shadow_banned: boolean;
 
-  user: UserResponse;
+  updated_at: Date;
 
-  type: string;
+  custom: Record<string, any>;
 
-  reason?: string;
+  archived_at?: Date;
 
-  sdk?: string;
+  ban_expires?: Date;
 
-  sdk_version?: string;
+  deleted_at?: Date;
 
-  custom?: Record<string, any>;
-}
+  invite_accepted_at?: Date;
 
-export interface CallUserMutedEvent {
-  call_cid: string;
+  invite_rejected_at?: Date;
 
-  created_at: Date;
+  invited?: boolean;
 
-  from_user_id: string;
+  is_moderator?: boolean;
 
-  muted_user_ids: string[];
+  pinned_at?: Date;
 
-  type: string;
-}
+  role?: 'member' | 'moderator' | 'admin' | 'owner';
 
-export interface CallsPerDayReport {
-  count: number;
+  status?: string;
+
+  user_id?: string;
+
+  user?: UserResponse;
 }
 
-export interface CallsPerDayReportResponse {
-  daily: DailyAggregateCallsPerDayReportResponse[];
+export interface ChannelMessages {
+  messages: Message[];
+
+  channel?: ChannelResponse;
 }
 
-export interface CampaignChannelTemplate {
-  type: string;
+export interface ChannelMute {
+  created_at: Date;
 
-  custom: Record<string, any>;
+  updated_at: Date;
 
-  id?: string;
+  expires?: Date;
 
-  team?: string;
+  channel?: ChannelResponse;
 
-  members?: string[];
+  user?: UserResponse;
 }
 
-export interface CampaignCompletedEvent {
+export interface ChannelMutedEvent {
   created_at: Date;
 
-  custom: Record<string, any>;
-
   type: string;
-
-  received_at?: Date;
-
-  campaign?: CampaignResponse;
 }
 
-export interface CampaignMessageTemplate {
-  poll_id: string;
+export const ChannelOwnCapability = {
+  BAN_CHANNEL_MEMBERS: 'ban-channel-members',
+  CAST_POLL_VOTE: 'cast-poll-vote',
+  CONNECT_EVENTS: 'connect-events',
+  CREATE_ATTACHMENT: 'create-attachment',
+  DELETE_ANY_MESSAGE: 'delete-any-message',
+  DELETE_CHANNEL: 'delete-channel',
+  DELETE_OWN_MESSAGE: 'delete-own-message',
+  FLAG_MESSAGE: 'flag-message',
+  FREEZE_CHANNEL: 'freeze-channel',
+  JOIN_CHANNEL: 'join-channel',
+  LEAVE_CHANNEL: 'leave-channel',
+  MUTE_CHANNEL: 'mute-channel',
+  PIN_MESSAGE: 'pin-message',
+  QUERY_POLL_VOTES: 'query-poll-votes',
+  QUOTE_MESSAGE: 'quote-message',
+  READ_EVENTS: 'read-events',
+  SEARCH_MESSAGES: 'search-messages',
+  SEND_CUSTOM_EVENTS: 'send-custom-events',
+  SEND_LINKS: 'send-links',
+  SEND_MESSAGE: 'send-message',
+  SEND_POLL: 'send-poll',
+  SEND_REACTION: 'send-reaction',
+  SEND_REPLY: 'send-reply',
+  SEND_RESTRICTED_VISIBILITY_MESSAGE: 'send-restricted-visibility-message',
+  SEND_TYPING_EVENTS: 'send-typing-events',
+  SET_CHANNEL_COOLDOWN: 'set-channel-cooldown',
+  SHARE_LOCATION: 'share-location',
+  SKIP_SLOW_MODE: 'skip-slow-mode',
+  SLOW_MODE: 'slow-mode',
+  TYPING_EVENTS: 'typing-events',
+  UPDATE_ANY_MESSAGE: 'update-any-message',
+  UPDATE_CHANNEL: 'update-channel',
+  UPDATE_CHANNEL_MEMBERS: 'update-channel-members',
+  UPDATE_OWN_MESSAGE: 'update-own-message',
+  UPDATE_THREAD: 'update-thread',
+  UPLOAD_FILE: 'upload-file',
+} as const;
 
-  text: string;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type ChannelOwnCapability =
+  (typeof ChannelOwnCapability)[keyof typeof ChannelOwnCapability];
 
-  attachments: Attachment[];
+export interface ChannelPushPreferences {
+  chat_level?: string;
 
-  custom: Record<string, any>;
+  disabled_until?: Date;
 }
 
-export interface CampaignResponse {
-  create_channels: boolean;
+export interface ChannelResponse {
+  cid: string;
 
   created_at: Date;
 
-  description: string;
+  disabled: boolean;
+
+  frozen: boolean;
 
   id: string;
 
-  name: string;
+  type: string;
 
-  sender_id: string;
+  updated_at: Date;
+
+  custom: Record<string, any>;
+
+  auto_translation_enabled?: boolean;
+
+  auto_translation_language?: string;
 
-  sender_mode: string;
+  blocked?: boolean;
 
-  show_channels: boolean;
+  cooldown?: number;
 
-  skip_push: boolean;
+  deleted_at?: Date;
 
-  skip_webhook: boolean;
+  hidden?: boolean;
 
-  status: string;
+  hide_messages_before?: Date;
 
-  updated_at: Date;
+  last_message_at?: Date;
 
-  segment_ids: string[];
+  member_count?: number;
 
-  segments: Segment[];
+  mute_expires_at?: Date;
 
-  user_ids: string[];
+  muted?: boolean;
 
-  users: UserResponse[];
+  team?: string;
 
-  stats: CampaignStatsResponse;
+  truncated_at?: Date;
 
-  scheduled_for?: Date;
+  members?: ChannelMember[];
 
-  stop_at?: Date;
+  own_capabilities?: ChannelOwnCapability[];
 
-  channel_template?: CampaignChannelTemplate;
+  config?: ChannelConfigWithInfo;
 
-  message_template?: CampaignMessageTemplate;
+  created_by?: UserResponse;
 
-  sender?: UserResponse;
+  truncated_by?: UserResponse;
 }
 
-export interface CampaignStartedEvent {
-  created_at: Date;
+export interface ChannelStateResponse {
+  duration: string;
 
-  custom: Record<string, any>;
+  members: ChannelMember[];
 
-  type: string;
+  messages: MessageResponse[];
 
-  received_at?: Date;
+  pinned_messages: MessageResponse[];
 
-  campaign?: CampaignResponse;
-}
+  threads: ThreadStateResponse[];
 
-export interface CampaignStatsResponse {
-  progress: number;
+  hidden?: boolean;
 
-  stats_channels_created: number;
+  hide_messages_before?: Date;
 
-  stats_completed_at: Date;
+  watcher_count?: number;
 
-  stats_messages_sent: number;
+  active_live_locations?: SharedLocationResponseData[];
 
-  stats_started_at: Date;
+  pending_messages?: PendingMessageResponse[];
 
-  stats_users_read: number;
+  read?: ReadStateResponse[];
 
-  stats_users_sent: number;
-}
+  watchers?: UserResponse[];
 
-export interface CastPollVoteRequest {
-  user_id?: string;
+  channel?: ChannelResponse;
 
-  user?: UserRequest;
+  draft?: DraftResponse;
 
-  vote?: VoteData;
-}
+  membership?: ChannelMember;
 
-export interface Channel {
-  auto_translation_language: string;
+  push_preferences?: ChannelPushPreferences;
+}
 
-  cid: string;
+export interface ChannelStateResponseFields {
+  members: ChannelMember[];
 
-  created_at: Date;
+  messages: MessageResponse[];
 
-  disabled: boolean;
+  pinned_messages: MessageResponse[];
 
-  frozen: boolean;
+  threads: ThreadStateResponse[];
 
-  id: string;
+  hidden?: boolean;
 
-  type: string;
+  hide_messages_before?: Date;
 
-  updated_at: Date;
+  watcher_count?: number;
 
-  custom: Record<string, any>;
+  active_live_locations?: SharedLocationResponseData[];
 
-  auto_translation_enabled?: boolean;
+  pending_messages?: PendingMessageResponse[];
 
-  cooldown?: number;
+  read?: ReadStateResponse[];
 
-  deleted_at?: Date;
+  watchers?: UserResponse[];
 
-  last_campaigns?: string;
+  channel?: ChannelResponse;
 
-  last_message_at?: Date;
+  draft?: DraftResponse;
 
-  member_count?: number;
+  membership?: ChannelMember;
 
-  team?: string;
+  push_preferences?: ChannelPushPreferences;
+}
 
-  active_live_locations?: SharedLocation[];
+export interface ChannelTruncatedEvent {
+  channel_id: string;
 
-  invites?: ChannelMember[];
+  channel_member_count: number;
 
-  members?: ChannelMember[];
+  channel_type: string;
 
-  config?: ChannelConfig;
+  cid: string;
 
-  config_overrides?: ConfigOverrides;
+  created_at: Date;
 
-  created_by?: User;
+  type: string;
 
-  truncated_by?: User;
+  channel?: ChannelResponse;
 }
 
-export interface ChannelConfig {
+export interface ChannelTypeConfig {
   automod: 'disabled' | 'simple' | 'AI';
 
   automod_behavior: 'flag' | 'block' | 'shadow_block';
@@ -2116,7 +3265,11 @@ export interface ChannelConfig {
 
   user_message_reminders: boolean;
 
-  commands: string[];
+  commands: Command[];
+
+  permissions: PolicyRequest[];
+
+  grants: Record<string, string[]>;
 
   blocklist?: string;
 
@@ -2124,7 +3277,7 @@ export interface ChannelConfig {
 
   partition_size?: number;
 
-  partition_ttl?: number;
+  partition_ttl?: string;
 
   allowed_flag_reasons?: string[];
 
@@ -2133,1914 +3286,2003 @@ export interface ChannelConfig {
   automod_thresholds?: Thresholds;
 }
 
-export interface ChannelConfigWithInfo {
-  automod: 'disabled' | 'simple' | 'AI';
+export interface ChannelUnFrozenEvent {
+  channel_id: string;
 
-  automod_behavior: 'flag' | 'block' | 'shadow_block';
+  channel_type: string;
 
-  connect_events: boolean;
+  cid: string;
 
   created_at: Date;
 
-  custom_events: boolean;
+  type: string;
+}
 
-  mark_messages_pending: boolean;
+export interface ChannelUnmutedEvent {
+  created_at: Date;
 
-  max_message_length: number;
+  type: string;
+}
 
-  mutes: boolean;
+export interface ChannelUpdatedEvent {
+  channel_id: string;
 
-  name: string;
+  channel_member_count: number;
 
-  polls: boolean;
+  channel_type: string;
 
-  push_notifications: boolean;
+  cid: string;
 
-  quotes: boolean;
+  created_at: Date;
 
-  reactions: boolean;
+  type: string;
 
-  read_events: boolean;
+  team?: string;
 
-  reminders: boolean;
+  channel?: ChannelResponse;
 
-  replies: boolean;
+  message?: Message;
 
-  search: boolean;
+  user?: User;
+}
 
-  shared_locations: boolean;
+export interface ChannelVisibleEvent {
+  channel_id: string;
 
-  skip_last_msg_update_for_system_msgs: boolean;
+  channel_type: string;
 
-  typing_events: boolean;
+  cid: string;
 
-  updated_at: Date;
+  created_at: Date;
 
-  uploads: boolean;
+  type: string;
 
-  url_enrichment: boolean;
+  user?: User;
+}
 
-  user_message_reminders: boolean;
+export interface ChatActivityStatsResponse {
+  messages?: MessageStatsResponse;
+}
 
-  commands: Command[];
+export interface CheckExternalStorageResponse {
+  duration: string;
 
-  blocklist?: string;
+  file_url: string;
+}
+
+export interface CheckPushRequest {
+  apn_template?: string;
+
+  event_type?:
+    | 'message.new'
+    | 'message.updated'
+    | 'reaction.new'
+    | 'reaction.updated'
+    | 'notification.reminder_due';
+
+  firebase_data_template?: string;
+
+  firebase_template?: string;
+
+  message_id?: string;
+
+  push_provider_name?: string;
+
+  push_provider_type?: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
+
+  skip_devices?: boolean;
+
+  user_id?: string;
+
+  user?: UserRequest;
+}
+
+export interface CheckPushResponse {
+  duration: string;
+
+  event_type?: string;
+
+  rendered_apn_template?: string;
+
+  rendered_firebase_template?: string;
+
+  skip_devices?: boolean;
+
+  general_errors?: string[];
+
+  device_errors?: Record<string, DeviceErrorInfo>;
+
+  rendered_message?: Record<string, string>;
+}
+
+export interface CheckRequest {
+  config_key: string;
+
+  entity_creator_id: string;
+
+  entity_id: string;
+
+  entity_type: string;
+
+  config_team?: string;
+
+  test_mode?: boolean;
+
+  user_id?: string;
+
+  moderation_payload?: ModerationPayload;
 
-  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
+  options?: Record<string, any>;
 
-  partition_size?: number;
+  user?: UserRequest;
+}
 
-  partition_ttl?: string;
+export interface CheckResponse {
+  duration: string;
 
-  allowed_flag_reasons?: string[];
+  recommended_action: string;
 
-  blocklists?: BlockListOptions[];
+  status: string;
 
-  automod_thresholds?: Thresholds;
+  task_id?: string;
 
-  grants?: Record<string, string[]>;
+  item?: ReviewQueueItemResponse;
 }
 
-export interface ChannelCreatedEvent {
-  created_at: Date;
+export interface CheckSNSRequest {
+  sns_key?: string;
 
-  type: string;
-}
+  sns_secret?: string;
 
-export interface ChannelDeletedEvent {
-  channel_id: string;
+  sns_topic_arn?: string;
+}
 
-  channel_member_count: number;
+export interface CheckSNSResponse {
+  duration: string;
 
-  channel_type: string;
+  status: 'ok' | 'error';
 
-  cid: string;
+  error?: string;
 
-  created_at: Date;
+  data?: Record<string, any>;
+}
 
-  type: string;
+export interface CheckSQSRequest {
+  sqs_key?: string;
 
-  team?: string;
+  sqs_secret?: string;
 
-  channel?: ChannelResponse;
+  sqs_url?: string;
 }
 
-export interface ChannelExport {
-  cid?: string;
-
-  id?: string;
+export interface CheckSQSResponse {
+  duration: string;
 
-  messages_since?: Date;
+  status: 'ok' | 'error';
 
-  messages_until?: Date;
+  error?: string;
 
-  type?: string;
+  data?: Record<string, any>;
 }
 
-export interface ChannelFrozenEvent {
-  channel_id: string;
+export interface ClientOSDataResponse {
+  architecture?: string;
 
-  channel_type: string;
+  name?: string;
 
-  cid: string;
+  version?: string;
+}
+
+export interface ClosedCaptionEvent {
+  call_cid: string;
 
   created_at: Date;
 
+  closed_caption: CallClosedCaption;
+
   type: string;
 }
 
-export interface ChannelGetOrCreateRequest {
-  hide_for_creator?: boolean;
-
-  state?: boolean;
+export interface CollectUserFeedbackRequest {
+  rating: number;
 
-  thread_unread_counts?: boolean;
+  sdk: string;
 
-  data?: ChannelInput;
+  sdk_version: string;
 
-  members?: PaginationParams;
+  reason?: string;
 
-  messages?: MessagePaginationParams;
+  user_session_id?: string;
 
-  watchers?: PaginationParams;
+  custom?: Record<string, any>;
 }
 
-export interface ChannelHiddenEvent {
-  channel_id: string;
-
-  channel_member_count: number;
-
-  channel_type: string;
+export interface CollectUserFeedbackResponse {
+  duration: string;
+}
 
-  cid: string;
+export interface Command {
+  args: string;
 
-  clear_history: boolean;
+  description: string;
 
-  created_at: Date;
+  name: string;
 
-  type: string;
+  set: string;
 
-  channel?: ChannelResponse;
+  created_at?: Date;
 
-  user?: User;
+  updated_at?: Date;
 }
 
-export interface ChannelInput {
-  auto_translation_enabled?: boolean;
+export interface CommentAddedEvent {
+  created_at: Date;
 
-  auto_translation_language?: string;
+  fid: string;
 
-  created_by_id?: string;
+  comment: CommentResponse;
 
-  disabled?: boolean;
+  custom: Record<string, any>;
 
-  frozen?: boolean;
+  type: string;
 
-  team?: string;
+  received_at?: Date;
 
-  truncated_by_id?: string;
+  user?: UserResponseCommonFields;
+}
 
-  invites?: ChannelMember[];
+export interface CommentDeletedEvent {
+  created_at: Date;
 
-  members?: ChannelMember[];
+  fid: string;
 
-  config_overrides?: ChannelConfig;
+  comment: CommentResponse;
 
-  created_by?: UserRequest;
+  custom: Record<string, any>;
 
-  custom?: Record<string, any>;
-}
+  type: string;
 
-export interface ChannelMember {
-  banned: boolean;
+  received_at?: Date;
 
-  channel_role: string;
+  user?: UserResponseCommonFields;
+}
 
+export interface CommentReactionAddedEvent {
   created_at: Date;
 
-  notifications_muted: boolean;
-
-  shadow_banned: boolean;
+  fid: string;
 
-  updated_at: Date;
+  comment: CommentResponse;
 
   custom: Record<string, any>;
 
-  archived_at?: Date;
-
-  ban_expires?: Date;
+  reaction: FeedsReactionResponse;
 
-  deleted_at?: Date;
+  type: string;
 
-  invite_accepted_at?: Date;
+  received_at?: Date;
 
-  invite_rejected_at?: Date;
+  user?: UserResponseCommonFields;
+}
 
-  invited?: boolean;
+export interface CommentReactionDeletedEvent {
+  created_at: Date;
 
-  is_moderator?: boolean;
+  fid: string;
 
-  pinned_at?: Date;
+  comment: CommentResponse;
 
-  role?: 'member' | 'moderator' | 'admin' | 'owner';
+  custom: Record<string, any>;
 
-  status?: string;
+  reaction: FeedsReactionResponse;
 
-  user_id?: string;
+  type: string;
 
-  user?: UserResponse;
+  received_at?: Date;
 }
 
-export interface ChannelMemberResponse {
-  banned: boolean;
-
-  channel_role: string;
-
+export interface CommentReactionUpdatedEvent {
   created_at: Date;
 
-  notifications_muted: boolean;
-
-  shadow_banned: boolean;
+  fid: string;
 
-  updated_at: Date;
+  comment: CommentResponse;
 
   custom: Record<string, any>;
 
-  archived_at?: Date;
-
-  ban_expires?: Date;
+  reaction: FeedsReactionResponse;
 
-  deleted_at?: Date;
+  type: string;
 
-  invite_accepted_at?: Date;
+  received_at?: Date;
 
-  invite_rejected_at?: Date;
+  user?: UserResponseCommonFields;
+}
 
-  invited?: boolean;
+export interface CommentResponse {
+  confidence_score: number;
 
-  is_moderator?: boolean;
+  created_at: Date;
 
-  pinned_at?: Date;
+  downvote_count: number;
 
-  role?: 'member' | 'moderator' | 'admin' | 'owner';
+  id: string;
 
-  status?: string;
+  object_id: string;
 
-  user_id?: string;
+  object_type: string;
 
-  user?: UserResponse;
-}
+  reaction_count: number;
 
-export interface ChannelMessages {
-  messages: Message[];
+  reply_count: number;
 
-  channel?: ChannelResponse;
-}
+  score: number;
 
-export interface ChannelMute {
-  created_at: Date;
+  status: string;
 
   updated_at: Date;
 
-  expires?: Date;
+  upvote_count: number;
 
-  channel?: ChannelResponse;
+  mentioned_users: UserResponse[];
 
-  user?: UserResponse;
-}
+  own_reactions: FeedsReactionResponse[];
 
-export interface ChannelMutedEvent {
-  created_at: Date;
+  user: UserResponse;
 
-  type: string;
-}
+  controversy_score?: number;
 
-export const ChannelOwnCapability = {
-  BAN_CHANNEL_MEMBERS: 'ban-channel-members',
-  CAST_POLL_VOTE: 'cast-poll-vote',
-  CONNECT_EVENTS: 'connect-events',
-  CREATE_ATTACHMENT: 'create-attachment',
-  DELETE_ANY_MESSAGE: 'delete-any-message',
-  DELETE_CHANNEL: 'delete-channel',
-  DELETE_OWN_MESSAGE: 'delete-own-message',
-  FLAG_MESSAGE: 'flag-message',
-  FREEZE_CHANNEL: 'freeze-channel',
-  JOIN_CHANNEL: 'join-channel',
-  LEAVE_CHANNEL: 'leave-channel',
-  MUTE_CHANNEL: 'mute-channel',
-  PIN_MESSAGE: 'pin-message',
-  QUERY_POLL_VOTES: 'query-poll-votes',
-  QUOTE_MESSAGE: 'quote-message',
-  READ_EVENTS: 'read-events',
-  SEARCH_MESSAGES: 'search-messages',
-  SEND_CUSTOM_EVENTS: 'send-custom-events',
-  SEND_LINKS: 'send-links',
-  SEND_MESSAGE: 'send-message',
-  SEND_POLL: 'send-poll',
-  SEND_REACTION: 'send-reaction',
-  SEND_REPLY: 'send-reply',
-  SEND_RESTRICTED_VISIBILITY_MESSAGE: 'send-restricted-visibility-message',
-  SEND_TYPING_EVENTS: 'send-typing-events',
-  SET_CHANNEL_COOLDOWN: 'set-channel-cooldown',
-  SHARE_LOCATION: 'share-location',
-  SKIP_SLOW_MODE: 'skip-slow-mode',
-  SLOW_MODE: 'slow-mode',
-  TYPING_EVENTS: 'typing-events',
-  UPDATE_ANY_MESSAGE: 'update-any-message',
-  UPDATE_CHANNEL: 'update-channel',
-  UPDATE_CHANNEL_MEMBERS: 'update-channel-members',
-  UPDATE_OWN_MESSAGE: 'update-own-message',
-  UPDATE_THREAD: 'update-thread',
-  UPLOAD_FILE: 'upload-file',
-} as const;
+  deleted_at?: Date;
 
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type ChannelOwnCapability =
-  (typeof ChannelOwnCapability)[keyof typeof ChannelOwnCapability];
+  parent_id?: string;
 
-export interface ChannelPushPreferences {
-  chat_level?: string;
+  text?: string;
 
-  disabled_until?: Date;
-}
+  attachments?: Attachment[];
 
-export interface ChannelResponse {
-  cid: string;
+  latest_reactions?: FeedsReactionResponse[];
 
-  created_at: Date;
+  custom?: Record<string, any>;
 
-  disabled: boolean;
+  moderation?: ModerationV2Response;
 
-  frozen: boolean;
+  reaction_groups?: Record<string, ReactionGroupResponse>;
+}
 
-  id: string;
+export interface CommentUpdatedEvent {
+  created_at: Date;
 
-  type: string;
+  fid: string;
 
-  updated_at: Date;
+  comment: CommentResponse;
 
   custom: Record<string, any>;
 
-  auto_translation_enabled?: boolean;
+  type: string;
 
-  auto_translation_language?: string;
+  received_at?: Date;
 
-  blocked?: boolean;
+  user?: UserResponseCommonFields;
+}
 
-  cooldown?: number;
+export interface CommitMessageRequest {}
 
-  deleted_at?: Date;
+export interface CompositeAppSettings {
+  json_encoded_settings?: string;
 
-  hidden?: boolean;
+  url?: string;
+}
 
-  hide_messages_before?: Date;
+export interface ConfigOverrides {
+  commands: string[];
 
-  last_message_at?: Date;
+  grants: Record<string, string[]>;
 
-  member_count?: number;
+  blocklist?: string;
 
-  mute_expires_at?: Date;
+  blocklist_behavior?: 'flag' | 'block';
 
-  muted?: boolean;
+  max_message_length?: number;
 
-  team?: string;
+  quotes?: boolean;
 
-  truncated_at?: Date;
+  reactions?: boolean;
 
-  members?: ChannelMember[];
+  replies?: boolean;
 
-  own_capabilities?: ChannelOwnCapability[];
+  shared_locations?: boolean;
 
-  config?: ChannelConfigWithInfo;
+  typing_events?: boolean;
 
-  created_by?: UserResponse;
+  uploads?: boolean;
 
-  truncated_by?: UserResponse;
-}
+  url_enrichment?: boolean;
 
-export interface ChannelStateResponse {
-  duration: string;
+  user_message_reminders?: boolean;
+}
 
-  members: ChannelMember[];
+export interface ConfigResponse {
+  async: boolean;
 
-  messages: MessageResponse[];
+  created_at: Date;
 
-  pinned_messages: MessageResponse[];
+  key: string;
 
-  threads: ThreadStateResponse[];
+  team: string;
 
-  hidden?: boolean;
+  updated_at: Date;
 
-  hide_messages_before?: Date;
+  ai_image_config?: AIImageConfig;
 
-  watcher_count?: number;
+  ai_text_config?: AITextConfig;
 
-  active_live_locations?: SharedLocationResponseData[];
+  ai_video_config?: AIVideoConfig;
 
-  pending_messages?: PendingMessageResponse[];
+  automod_platform_circumvention_config?: AutomodPlatformCircumventionConfig;
 
-  read?: ReadStateResponse[];
+  automod_semantic_filters_config?: AutomodSemanticFiltersConfig;
 
-  watchers?: UserResponse[];
+  automod_toxicity_config?: AutomodToxicityConfig;
 
-  channel?: ChannelResponse;
+  block_list_config?: BlockListConfig;
 
-  draft?: DraftResponse;
+  rule_builder_config?: RuleBuilderConfig;
 
-  membership?: ChannelMember;
+  velocity_filter_config?: VelocityFilterConfig;
 
-  push_preferences?: ChannelPushPreferences;
+  video_call_rule_config?: VideoCallRuleConfig;
 }
 
-export interface ChannelStateResponseFields {
-  members: ChannelMember[];
+export interface ContentCountRuleParameters {
+  threshold: number;
 
-  messages: MessageResponse[];
+  time_window: string;
+}
 
-  pinned_messages: MessageResponse[];
+export interface CountByMinuteResponse {
+  count: number;
 
-  threads: ThreadStateResponse[];
+  start_ts: Date;
+}
 
-  hidden?: boolean;
+export interface CreateBlockListRequest {
+  name: string;
 
-  hide_messages_before?: Date;
+  words: string[];
 
-  watcher_count?: number;
+  team?: string;
 
-  active_live_locations?: SharedLocationResponseData[];
+  type?: 'regex' | 'domain' | 'domain_allowlist' | 'email' | 'word';
+}
 
-  pending_messages?: PendingMessageResponse[];
+export interface CreateBlockListResponse {
+  duration: string;
 
-  read?: ReadStateResponse[];
+  blocklist?: BlockListResponse;
+}
 
-  watchers?: UserResponse[];
+export interface CreateCallTypeRequest {
+  name: string;
 
-  channel?: ChannelResponse;
+  external_storage?: string;
 
-  draft?: DraftResponse;
+  grants?: Record<string, string[]>;
 
-  membership?: ChannelMember;
+  notification_settings?: NotificationSettings;
 
-  push_preferences?: ChannelPushPreferences;
+  settings?: CallSettingsRequest;
 }
 
-export interface ChannelTruncatedEvent {
-  channel_id: string;
+export interface CreateCallTypeResponse {
+  created_at: Date;
 
-  channel_member_count: number;
+  duration: string;
 
-  channel_type: string;
+  name: string;
 
-  cid: string;
+  updated_at: Date;
 
-  created_at: Date;
+  grants: Record<string, string[]>;
 
-  type: string;
+  notification_settings: NotificationSettings;
 
-  channel?: ChannelResponse;
+  settings: CallSettingsResponse;
+
+  external_storage?: string;
 }
 
-export interface ChannelTypeConfig {
+export interface CreateChannelTypeRequest {
   automod: 'disabled' | 'simple' | 'AI';
 
-  automod_behavior: 'flag' | 'block' | 'shadow_block';
-
-  connect_events: boolean;
-
-  created_at: Date;
-
-  custom_events: boolean;
-
-  mark_messages_pending: boolean;
+  automod_behavior: 'flag' | 'block';
 
   max_message_length: number;
 
-  mutes: boolean;
-
   name: string;
 
-  polls: boolean;
+  blocklist?: string;
 
-  push_notifications: boolean;
+  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
 
-  quotes: boolean;
+  connect_events?: boolean;
 
-  reactions: boolean;
+  custom_events?: boolean;
 
-  read_events: boolean;
+  mark_messages_pending?: boolean;
 
-  reminders: boolean;
+  message_retention?: 'infinite' | 'numeric';
 
-  replies: boolean;
+  mutes?: boolean;
 
-  search: boolean;
+  partition_size?: number;
 
-  shared_locations: boolean;
+  partition_ttl?: string;
 
-  skip_last_msg_update_for_system_msgs: boolean;
+  polls?: boolean;
 
-  typing_events: boolean;
+  push_notifications?: boolean;
 
-  updated_at: Date;
+  reactions?: boolean;
 
-  uploads: boolean;
+  read_events?: boolean;
 
-  url_enrichment: boolean;
+  replies?: boolean;
 
-  user_message_reminders: boolean;
+  search?: boolean;
 
-  commands: Command[];
+  shared_locations?: boolean;
 
-  permissions: PolicyRequest[];
+  skip_last_msg_update_for_system_msgs?: boolean;
 
-  grants: Record<string, string[]>;
+  typing_events?: boolean;
 
-  blocklist?: string;
+  uploads?: boolean;
 
-  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
+  url_enrichment?: boolean;
 
-  partition_size?: number;
+  user_message_reminders?: boolean;
 
-  partition_ttl?: string;
+  blocklists?: BlockListOptions[];
 
-  allowed_flag_reasons?: string[];
+  commands?: string[];
 
-  blocklists?: BlockListOptions[];
+  permissions?: PolicyRequest[];
 
-  automod_thresholds?: Thresholds;
+  grants?: Record<string, string[]>;
 }
 
-export interface ChannelUnFrozenEvent {
-  channel_id: string;
+export interface CreateChannelTypeResponse {
+  automod: 'disabled' | 'simple' | 'AI';
 
-  channel_type: string;
+  automod_behavior: 'flag' | 'block' | 'shadow_block';
 
-  cid: string;
+  connect_events: boolean;
 
   created_at: Date;
 
-  type: string;
-}
+  custom_events: boolean;
 
-export interface ChannelUnmutedEvent {
-  created_at: Date;
+  duration: string;
 
-  type: string;
-}
+  mark_messages_pending: boolean;
 
-export interface ChannelUpdatedEvent {
-  channel_id: string;
+  max_message_length: number;
 
-  channel_member_count: number;
+  mutes: boolean;
 
-  channel_type: string;
+  name: string;
 
-  cid: string;
+  polls: boolean;
 
-  created_at: Date;
+  push_notifications: boolean;
 
-  type: string;
+  quotes: boolean;
 
-  team?: string;
+  reactions: boolean;
 
-  channel?: ChannelResponse;
+  read_events: boolean;
 
-  message?: Message;
+  reminders: boolean;
+
+  replies: boolean;
+
+  search: boolean;
+
+  shared_locations: boolean;
 
-  user?: User;
-}
+  skip_last_msg_update_for_system_msgs: boolean;
 
-export interface ChannelVisibleEvent {
-  channel_id: string;
+  typing_events: boolean;
 
-  channel_type: string;
+  updated_at: Date;
 
-  cid: string;
+  uploads: boolean;
 
-  created_at: Date;
+  url_enrichment: boolean;
 
-  type: string;
+  user_message_reminders: boolean;
 
-  user?: User;
-}
+  commands: string[];
 
-export interface ChatActivityStatsResponse {
-  messages?: MessageStatsResponse;
-}
+  permissions: PolicyRequest[];
 
-export interface CheckExternalStorageResponse {
-  duration: string;
+  grants: Record<string, string[]>;
 
-  file_url: string;
-}
+  blocklist?: string;
 
-export interface CheckPushRequest {
-  apn_template?: string;
+  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
 
-  event_type?:
-    | 'message.new'
-    | 'message.updated'
-    | 'reaction.new'
-    | 'reaction.updated'
-    | 'notification.reminder_due';
+  partition_size?: number;
 
-  firebase_data_template?: string;
+  partition_ttl?: string;
 
-  firebase_template?: string;
+  allowed_flag_reasons?: string[];
 
-  message_id?: string;
+  blocklists?: BlockListOptions[];
 
-  push_provider_name?: string;
+  automod_thresholds?: Thresholds;
+}
 
-  push_provider_type?: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
+export interface CreateCommandRequest {
+  description: string;
 
-  skip_devices?: boolean;
+  name: string;
 
-  user_id?: string;
+  args?: string;
 
-  user?: UserRequest;
+  set?: string;
 }
 
-export interface CheckPushResponse {
+export interface CreateCommandResponse {
   duration: string;
 
-  event_type?: string;
+  command?: Command;
+}
 
-  rendered_apn_template?: string;
+export interface CreateDeviceRequest {
+  id: string;
 
-  rendered_firebase_template?: string;
+  push_provider: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
 
-  skip_devices?: boolean;
+  push_provider_name?: string;
 
-  general_errors?: string[];
+  user_id?: string;
 
-  device_errors?: Record<string, DeviceErrorInfo>;
+  voip_token?: boolean;
 
-  rendered_message?: Record<string, string>;
+  user?: UserRequest;
 }
 
-export interface CheckRequest {
-  config_key: string;
-
-  entity_creator_id: string;
-
-  entity_id: string;
-
-  entity_type: string;
+export interface CreateExternalStorageRequest {
+  bucket: string;
 
-  config_team?: string;
+  name: string;
 
-  test_mode?: boolean;
+  storage_type: 's3' | 'gcs' | 'abs';
 
-  user_id?: string;
+  gcs_credentials?: string;
 
-  moderation_payload?: ModerationPayload;
+  path?: string;
 
-  options?: Record<string, any>;
+  aws_s3?: S3Request;
 
-  user?: UserRequest;
+  azure_blob?: AzureRequest;
 }
 
-export interface CheckResponse {
+export interface CreateExternalStorageResponse {
   duration: string;
+}
 
-  recommended_action: string;
-
-  status: string;
-
-  task_id?: string;
+export interface CreateFeedGroupRequest {
+  feed_group_id: string;
 
-  item?: ReviewQueueItemResponse;
-}
+  default_view_id?: string;
 
-export interface CheckSNSRequest {
-  sns_key?: string;
+  default_visibility?:
+    | 'public'
+    | 'visible'
+    | 'followers'
+    | 'members'
+    | 'private';
 
-  sns_secret?: string;
+  custom?: Record<string, any>;
 
-  sns_topic_arn?: string;
+  notification?: NotificationConfig;
 }
 
-export interface CheckSNSResponse {
+export interface CreateFeedGroupResponse {
   duration: string;
 
-  status: 'ok' | 'error';
+  feed_group: FeedGroupResponse;
+}
 
-  error?: string;
+export interface CreateFeedViewRequest {
+  view_id: string;
 
-  data?: Record<string, any>;
-}
+  activity_processors?: ActivityProcessorConfig[];
 
-export interface CheckSQSRequest {
-  sqs_key?: string;
+  activity_selectors?: ActivitySelectorConfig[];
 
-  sqs_secret?: string;
+  aggregation?: AggregationConfig;
 
-  sqs_url?: string;
+  ranking?: RankingConfig;
 }
 
-export interface CheckSQSResponse {
+export interface CreateFeedViewResponse {
   duration: string;
 
-  status: 'ok' | 'error';
-
-  error?: string;
-
-  data?: Record<string, any>;
+  feed_view: FeedViewResponse;
 }
 
-export interface ClientOSDataResponse {
-  architecture?: string;
+export interface CreateFeedsBatchRequest {
+  feeds: FeedRequest[];
+}
 
-  name?: string;
+export interface CreateFeedsBatchResponse {
+  duration: string;
 
-  version?: string;
+  feeds: FeedResponse[];
 }
 
-export interface ClosedCaptionEvent {
-  call_cid: string;
+export interface CreateGuestRequest {
+  user: UserRequest;
+}
 
-  created_at: Date;
+export interface CreateGuestResponse {
+  access_token: string;
 
-  closed_caption: CallClosedCaption;
+  duration: string;
 
-  type: string;
+  user: UserResponse;
 }
 
-export interface CollectUserFeedbackRequest {
-  rating: number;
-
-  sdk: string;
+export interface CreateImportRequest {
+  mode: 'insert' | 'upsert';
 
-  sdk_version: string;
+  path: string;
+}
 
-  reason?: string;
+export interface CreateImportResponse {
+  duration: string;
 
-  user_session_id?: string;
+  import_task?: ImportTask;
+}
 
-  custom?: Record<string, any>;
+export interface CreateImportURLRequest {
+  filename?: string;
 }
 
-export interface CollectUserFeedbackResponse {
+export interface CreateImportURLResponse {
   duration: string;
-}
 
-export interface Command {
-  args: string;
+  path: string;
 
-  description: string;
+  upload_url: string;
+}
 
-  name: string;
+export interface CreatePollOptionRequest {
+  text: string;
 
-  set: string;
+  user_id?: string;
 
-  created_at?: Date;
+  custom?: Record<string, any>;
 
-  updated_at?: Date;
+  user?: UserRequest;
 }
 
-export interface CommitMessageRequest {}
+export interface CreatePollRequest {
+  name: string;
 
-export interface CompositeAppSettings {
-  json_encoded_settings?: string;
+  allow_answers?: boolean;
 
-  url?: string;
-}
+  allow_user_suggested_options?: boolean;
 
-export interface ConfigOverrides {
-  commands: string[];
+  description?: string;
 
-  grants: Record<string, string[]>;
+  enforce_unique_vote?: boolean;
 
-  blocklist?: string;
+  id?: string;
 
-  blocklist_behavior?: 'flag' | 'block';
+  is_closed?: boolean;
 
-  max_message_length?: number;
+  max_votes_allowed?: number;
 
-  quotes?: boolean;
+  user_id?: string;
 
-  reactions?: boolean;
+  voting_visibility?: 'anonymous' | 'public';
 
-  replies?: boolean;
+  options?: PollOptionInput[];
 
-  shared_locations?: boolean;
+  custom?: Record<string, any>;
 
-  typing_events?: boolean;
+  user?: UserRequest;
+}
 
-  uploads?: boolean;
+export interface CreateReminderRequest {
+  remind_at?: Date;
 
-  url_enrichment?: boolean;
+  user_id?: string;
 
-  user_message_reminders?: boolean;
+  user?: UserRequest;
 }
 
-export interface ConfigResponse {
-  async: boolean;
+export interface CreateRoleRequest {
+  name: string;
+}
 
-  created_at: Date;
+export interface CreateRoleResponse {
+  duration: string;
 
-  key: string;
+  role: Role;
+}
 
-  team: string;
+export interface CustomActionRequest {
+  id?: string;
 
-  updated_at: Date;
+  options?: Record<string, any>;
+}
 
-  ai_image_config?: AIImageConfig;
+export interface CustomCheckFlag {
+  type: string;
 
-  ai_text_config?: AITextConfig;
+  reason?: string;
 
-  ai_video_config?: AIVideoConfig;
+  labels?: string[];
 
-  automod_platform_circumvention_config?: AutomodPlatformCircumventionConfig;
+  custom?: Record<string, any>;
+}
 
-  automod_semantic_filters_config?: AutomodSemanticFiltersConfig;
+export interface CustomCheckRequest {
+  entity_id: string;
 
-  automod_toxicity_config?: AutomodToxicityConfig;
+  entity_type: string;
 
-  block_list_config?: BlockListConfig;
+  flags: CustomCheckFlag[];
 
-  rule_builder_config?: RuleBuilderConfig;
+  entity_creator_id?: string;
+
+  user_id?: string;
 
-  velocity_filter_config?: VelocityFilterConfig;
+  moderation_payload?: ModerationPayload;
 
-  video_call_rule_config?: VideoCallRuleConfig;
+  user?: UserRequest;
 }
 
-export interface ContentCountRuleParameters {
-  threshold: number;
+export interface CustomCheckResponse {
+  duration: string;
 
-  time_window: string;
-}
+  id: string;
 
-export interface CountByMinuteResponse {
-  count: number;
+  status: string;
 
-  start_ts: Date;
+  item?: ReviewQueueItemResponse;
 }
 
-export interface CreateBlockListRequest {
-  name: string;
+export interface CustomVideoEvent {
+  call_cid: string;
 
-  words: string[];
+  created_at: Date;
 
-  team?: string;
+  custom: Record<string, any>;
 
-  type?: 'regex' | 'domain' | 'domain_allowlist' | 'email' | 'word';
+  user: UserResponse;
+
+  type: string;
 }
 
-export interface CreateBlockListResponse {
-  duration: string;
+export interface DailyAggregateCallDurationReportResponse {
+  date: string;
 
-  blocklist?: BlockListResponse;
+  report: CallDurationReport;
 }
 
-export interface CreateCallTypeRequest {
-  name: string;
-
-  external_storage?: string;
+export interface DailyAggregateCallParticipantCountReportResponse {
+  date: string;
 
-  grants?: Record<string, string[]>;
+  report: CallParticipantCountReport;
+}
 
-  notification_settings?: NotificationSettings;
+export interface DailyAggregateCallsPerDayReportResponse {
+  date: string;
 
-  settings?: CallSettingsRequest;
+  report: CallsPerDayReport;
 }
 
-export interface CreateCallTypeResponse {
-  created_at: Date;
-
-  duration: string;
+export interface DailyAggregateQualityScoreReportResponse {
+  date: string;
 
-  name: string;
+  report: QualityScoreReport;
+}
 
-  updated_at: Date;
+export interface DailyAggregateSDKUsageReportResponse {
+  date: string;
 
-  grants: Record<string, string[]>;
+  report: SDKUsageReport;
+}
 
-  notification_settings: NotificationSettings;
+export interface DailyAggregateUserFeedbackReportResponse {
+  date: string;
 
-  settings: CallSettingsResponse;
+  report: UserFeedbackReport;
+}
 
-  external_storage?: string;
+export interface Data {
+  id: string;
 }
 
-export interface CreateChannelTypeRequest {
-  automod: 'disabled' | 'simple' | 'AI';
+export interface DataDogInfo {
+  api_key?: string;
 
-  automod_behavior: 'flag' | 'block';
+  enabled?: boolean;
 
-  max_message_length: number;
+  site?: string;
+}
 
-  name: string;
+export interface DeactivateUserRequest {
+  created_by_id?: string;
 
-  blocklist?: string;
+  mark_messages_deleted?: boolean;
+}
 
-  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
+export interface DeactivateUserResponse {
+  duration: string;
 
-  connect_events?: boolean;
+  user?: UserResponse;
+}
 
-  custom_events?: boolean;
+export interface DeactivateUsersRequest {
+  user_ids: string[];
 
-  mark_messages_pending?: boolean;
+  created_by_id?: string;
 
-  message_retention?: 'infinite' | 'numeric';
+  mark_channels_deleted?: boolean;
 
-  mutes?: boolean;
+  mark_messages_deleted?: boolean;
+}
 
-  partition_size?: number;
+export interface DeactivateUsersResponse {
+  duration: string;
 
-  partition_ttl?: string;
+  task_id: string;
+}
 
-  polls?: boolean;
+export interface DecayFunctionConfig {
+  base?: string;
 
-  push_notifications?: boolean;
+  decay?: string;
 
-  reactions?: boolean;
+  direction?: string;
 
-  read_events?: boolean;
+  offset?: string;
 
-  replies?: boolean;
+  origin?: string;
 
-  search?: boolean;
+  scale?: string;
+}
 
-  shared_locations?: boolean;
+export interface DeleteActivitiesRequest {
+  activity_ids: string[];
 
-  skip_last_msg_update_for_system_msgs?: boolean;
+  hard_delete?: boolean;
 
-  typing_events?: boolean;
+  user_id?: string;
 
-  uploads?: boolean;
+  user?: UserRequest;
+}
 
-  url_enrichment?: boolean;
+export interface DeleteActivitiesResponse {
+  duration: string;
 
-  user_message_reminders?: boolean;
+  deleted_activity_ids: string[];
+}
 
-  blocklists?: BlockListOptions[];
+export interface DeleteActivityReactionResponse {
+  duration: string;
 
-  commands?: string[];
+  activity: ActivityResponse;
 
-  permissions?: PolicyRequest[];
+  reaction: FeedsReactionResponse;
+}
 
-  grants?: Record<string, string[]>;
+export interface DeleteActivityRequest {
+  hard_delete?: boolean;
 }
 
-export interface CreateChannelTypeResponse {
-  automod: 'disabled' | 'simple' | 'AI';
+export interface DeleteActivityResponse {
+  duration: string;
+}
 
-  automod_behavior: 'flag' | 'block' | 'shadow_block';
+export interface DeleteBookmarkFolderResponse {
+  duration: string;
+}
 
-  connect_events: boolean;
+export interface DeleteBookmarkResponse {
+  duration: string;
 
-  created_at: Date;
+  bookmark: BookmarkResponse;
+}
 
-  custom_events: boolean;
+export interface DeleteCallRequest {
+  hard?: boolean;
+}
 
+export interface DeleteCallResponse {
   duration: string;
 
-  mark_messages_pending: boolean;
+  call: CallResponse;
 
-  max_message_length: number;
+  task_id?: string;
+}
 
-  mutes: boolean;
+export interface DeleteChannelResponse {
+  duration: string;
 
-  name: string;
+  channel?: ChannelResponse;
+}
 
-  polls: boolean;
+export interface DeleteChannelsRequest {
+  cids: string[];
 
-  push_notifications: boolean;
+  hard_delete?: boolean;
+}
 
-  quotes: boolean;
+export interface DeleteChannelsResponse {
+  duration: string;
 
-  reactions: boolean;
+  task_id?: string;
 
-  read_events: boolean;
+  result?: Record<string, DeleteChannelsResultResponse>;
+}
 
-  reminders: boolean;
+export interface DeleteChannelsResultResponse {
+  status: string;
 
-  replies: boolean;
+  error?: string;
+}
 
-  search: boolean;
+export interface DeleteCommandResponse {
+  duration: string;
 
-  shared_locations: boolean;
+  name: string;
+}
 
-  skip_last_msg_update_for_system_msgs: boolean;
+export interface DeleteCommentReactionResponse {
+  duration: string;
 
-  typing_events: boolean;
+  comment: CommentResponse;
 
-  updated_at: Date;
+  reaction: FeedsReactionResponse;
+}
 
-  uploads: boolean;
+export interface DeleteCommentResponse {
+  duration: string;
+}
 
-  url_enrichment: boolean;
+export interface DeleteExternalStorageResponse {
+  duration: string;
+}
 
-  user_message_reminders: boolean;
+export interface DeleteFeedGroupResponse {
+  duration: string;
+}
 
-  commands: string[];
+export interface DeleteFeedResponse {
+  duration: string;
+}
 
-  permissions: PolicyRequest[];
+export interface DeleteFeedUserDataResponse {
+  deleted_activities: number;
 
-  grants: Record<string, string[]>;
+  deleted_bookmarks: number;
 
-  blocklist?: string;
+  deleted_comments: number;
 
-  blocklist_behavior?: 'flag' | 'block' | 'shadow_block';
+  deleted_reactions: number;
 
-  partition_size?: number;
+  duration: string;
+}
 
-  partition_ttl?: string;
+export interface DeleteFeedViewResponse {
+  duration: string;
+}
 
-  allowed_flag_reasons?: string[];
+export interface DeleteMessageRequest {
+  hard_delete?: boolean;
+}
 
-  blocklists?: BlockListOptions[];
+export interface DeleteMessageResponse {
+  duration: string;
 
-  automod_thresholds?: Thresholds;
+  message: MessageResponse;
 }
 
-export interface CreateCommandRequest {
-  description: string;
+export interface DeleteModerationConfigResponse {
+  duration: string;
+}
 
-  name: string;
+export interface DeleteModerationTemplateResponse {
+  duration: string;
+}
 
-  args?: string;
+export interface DeleteReactionRequest {
+  hard_delete?: boolean;
+}
 
-  set?: string;
+export interface DeleteReactionResponse {
+  duration: string;
+
+  message: MessageResponse;
+
+  reaction: ReactionResponse;
 }
 
-export interface CreateCommandResponse {
+export interface DeleteRecordingResponse {
   duration: string;
+}
 
-  command?: Command;
+export interface DeleteReminderResponse {
+  duration: string;
 }
 
-export interface CreateDeviceRequest {
-  id: string;
+export interface DeleteSegmentTargetsRequest {
+  target_ids: string[];
+}
 
-  push_provider: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
+export interface DeleteTranscriptionResponse {
+  duration: string;
+}
 
-  push_provider_name?: string;
+export interface DeleteUserRequest {
+  delete_conversation_channels?: boolean;
 
-  user_id?: string;
+  delete_feeds_content?: boolean;
 
-  voip_token?: boolean;
+  hard_delete?: boolean;
 
-  user?: UserRequest;
+  mark_messages_deleted?: boolean;
 }
 
-export interface CreateExternalStorageRequest {
-  bucket: string;
+export interface DeleteUsersRequest {
+  user_ids: string[];
 
-  name: string;
+  calls?: 'soft' | 'hard';
 
-  storage_type: 's3' | 'gcs' | 'abs';
+  conversations?: 'soft' | 'hard';
 
-  gcs_credentials?: string;
+  messages?: 'soft' | 'pruning' | 'hard';
 
-  path?: string;
+  new_call_owner_id?: string;
 
-  aws_s3?: S3Request;
+  new_channel_owner_id?: string;
 
-  azure_blob?: AzureRequest;
+  user?: 'soft' | 'pruning' | 'hard';
 }
 
-export interface CreateExternalStorageResponse {
+export interface DeleteUsersResponse {
   duration: string;
-}
 
-export interface CreateGuestRequest {
-  user: UserRequest;
+  task_id: string;
 }
 
-export interface CreateGuestResponse {
-  access_token: string;
+export interface Device {
+  created_at: Date;
 
-  duration: string;
+  id: string;
 
-  user: UserResponse;
-}
+  push_provider: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
 
-export interface CreateImportRequest {
-  mode: 'insert' | 'upsert';
+  user_id: string;
 
-  path: string;
-}
+  disabled?: boolean;
 
-export interface CreateImportResponse {
-  duration: string;
+  disabled_reason?: string;
 
-  import_task?: ImportTask;
+  push_provider_name?: string;
+
+  voip?: boolean;
 }
 
-export interface CreateImportURLRequest {
-  filename?: string;
+export interface DeviceDataResponse {
+  name?: string;
+
+  version?: string;
 }
 
-export interface CreateImportURLResponse {
-  duration: string;
+export interface DeviceErrorInfo {
+  error_message: string;
 
-  path: string;
+  provider: string;
 
-  upload_url: string;
+  provider_name: string;
 }
 
-export interface CreatePollOptionRequest {
-  text: string;
+export interface DeviceResponse {
+  created_at: Date;
 
-  position?: number;
+  id: string;
 
-  user_id?: string;
+  push_provider: string;
 
-  custom?: Record<string, any>;
+  user_id: string;
 
-  user?: UserRequest;
-}
+  disabled?: boolean;
 
-export interface CreatePollRequest {
-  name: string;
+  disabled_reason?: string;
 
-  allow_answers?: boolean;
+  push_provider_name?: string;
 
-  allow_user_suggested_options?: boolean;
+  voip?: boolean;
+}
 
-  description?: string;
+export interface DraftPayloadResponse {
+  id: string;
 
-  enforce_unique_vote?: boolean;
+  text: string;
 
-  id?: string;
+  custom: Record<string, any>;
 
-  is_closed?: boolean;
+  html?: string;
 
-  max_votes_allowed?: number;
+  mml?: string;
 
-  user_id?: string;
+  parent_id?: string;
 
-  voting_visibility?: 'anonymous' | 'public';
+  poll_id?: string;
 
-  options?: PollOptionInput[];
+  quoted_message_id?: string;
 
-  custom?: Record<string, any>;
+  show_in_channel?: boolean;
 
-  user?: UserRequest;
-}
+  silent?: boolean;
 
-export interface CreateReminderRequest {
-  remind_at?: Date;
+  type?: string;
 
-  user_id?: string;
+  attachments?: Attachment[];
 
-  user?: UserRequest;
+  mentioned_users?: UserResponse[];
 }
 
-export interface CreateRoleRequest {
-  name: string;
-}
+export interface DraftResponse {
+  channel_cid: string;
 
-export interface CreateRoleResponse {
-  duration: string;
+  created_at: Date;
 
-  role: Role;
-}
+  message: DraftPayloadResponse;
 
-export interface CustomActionRequest {
-  id?: string;
+  parent_id?: string;
 
-  options?: Record<string, any>;
+  channel?: ChannelResponse;
+
+  parent_message?: MessageResponse;
+
+  quoted_message?: MessageResponse;
 }
 
-export interface CustomCheckFlag {
-  type: string;
+export interface EdgeResponse {
+  continent_code: string;
 
-  reason?: string;
+  country_iso_code: string;
 
-  labels?: string[];
+  green: number;
 
-  custom?: Record<string, any>;
-}
+  id: string;
 
-export interface CustomCheckRequest {
-  entity_id: string;
+  latency_test_url: string;
 
-  entity_type: string;
+  latitude: number;
 
-  flags: CustomCheckFlag[];
+  longitude: number;
 
-  entity_creator_id?: string;
+  red: number;
 
-  user_id?: string;
+  subdivision_iso_code: string;
 
-  moderation_payload?: ModerationPayload;
+  yellow: number;
+}
 
-  user?: UserRequest;
+export interface EgressHLSResponse {
+  playlist_url: string;
+
+  status: string;
 }
 
-export interface CustomCheckResponse {
-  duration: string;
+export interface EgressRTMPResponse {
+  name: string;
 
-  id: string;
+  started_at: Date;
 
-  status: string;
+  stream_key?: string;
 
-  item?: ReviewQueueItemResponse;
+  stream_url?: string;
 }
 
-export interface CustomVideoEvent {
-  call_cid: string;
-
-  created_at: Date;
+export interface EgressResponse {
+  broadcasting: boolean;
 
-  custom: Record<string, any>;
+  rtmps: EgressRTMPResponse[];
 
-  user: UserResponse;
+  frame_recording?: FrameRecordingResponse;
 
-  type: string;
+  hls?: EgressHLSResponse;
 }
 
-export interface DailyAggregateCallDurationReportResponse {
-  date: string;
+export interface EgressTaskConfig {
+  egress_user?: EgressUser;
 
-  report: CallDurationReport;
-}
+  frame_recording_egress_config?: FrameRecordingEgressConfig;
 
-export interface DailyAggregateCallParticipantCountReportResponse {
-  date: string;
+  hls_egress_config?: HLSEgressConfig;
 
-  report: CallParticipantCountReport;
-}
+  recording_egress_config?: RecordingEgressConfig;
 
-export interface DailyAggregateCallsPerDayReportResponse {
-  date: string;
+  rtmp_egress_config?: RTMPEgressConfig;
 
-  report: CallsPerDayReport;
+  stt_egress_config?: STTEgressConfig;
 }
 
-export interface DailyAggregateQualityScoreReportResponse {
-  date: string;
-
-  report: QualityScoreReport;
+export interface EgressUser {
+  token?: string;
 }
 
-export interface DailyAggregateSDKUsageReportResponse {
-  date: string;
+export interface EndCallRequest {}
 
-  report: SDKUsageReport;
+export interface EndCallResponse {
+  duration: string;
 }
 
-export interface DailyAggregateUserFeedbackReportResponse {
-  date: string;
+export interface EnrichedActivity {
+  foreign_id?: string;
 
-  report: UserFeedbackReport;
-}
+  id?: string;
 
-export interface Data {
-  id: string;
-}
+  score?: number;
 
-export interface DataDogInfo {
-  api_key?: string;
+  verb?: string;
 
-  enabled?: boolean;
+  to?: string[];
 
-  site?: string;
-}
+  actor?: Data;
 
-export interface DeactivateUserRequest {
-  created_by_id?: string;
+  latest_reactions?: Record<string, EnrichedReaction[]>;
 
-  mark_messages_deleted?: boolean;
-}
+  object?: Data;
 
-export interface DeactivateUserResponse {
-  duration: string;
+  origin?: Data;
 
-  user?: UserResponse;
+  own_reactions?: Record<string, EnrichedReaction[]>;
+
+  reaction_counts?: Record<string, number>;
+
+  target?: Data;
 }
 
-export interface DeactivateUsersRequest {
-  user_ids: string[];
+export interface EnrichedReaction {
+  activity_id: string;
 
-  created_by_id?: string;
+  kind: string;
 
-  mark_channels_deleted?: boolean;
+  user_id: string;
 
-  mark_messages_deleted?: boolean;
-}
+  id?: string;
 
-export interface DeactivateUsersResponse {
-  duration: string;
+  parent?: string;
 
-  task_id: string;
-}
+  target_feeds?: string[];
 
-export interface DeleteActivityRequest {
-  hard_delete?: boolean;
-}
+  children_counts?: Record<string, number>;
 
-export interface DeleteCallRequest {
-  hard?: boolean;
-}
+  created_at?: Time;
 
-export interface DeleteCallResponse {
-  duration: string;
+  data?: Record<string, any>;
 
-  call: CallResponse;
+  latest_children?: Record<string, EnrichedReaction[]>;
 
-  task_id?: string;
-}
+  own_children?: Record<string, EnrichedReaction[]>;
 
-export interface DeleteChannelResponse {
-  duration: string;
+  updated_at?: Time;
 
-  channel?: ChannelResponse;
+  user?: Data;
 }
 
-export interface DeleteChannelsRequest {
-  cids: string[];
+export interface EntityCreator {
+  ban_count: number;
 
-  hard_delete?: boolean;
-}
+  banned: boolean;
 
-export interface DeleteChannelsResponse {
-  duration: string;
+  deleted_content_count: number;
 
-  task_id?: string;
+  id: string;
 
-  result?: Record<string, DeleteChannelsResultResponse>;
-}
+  online: boolean;
 
-export interface DeleteChannelsResultResponse {
-  status: string;
+  role: string;
 
-  error?: string;
-}
+  custom: Record<string, any>;
 
-export interface DeleteCommandResponse {
-  duration: string;
+  teams_role: Record<string, string>;
 
-  name: string;
-}
+  ban_expires?: Date;
 
-export interface DeleteExternalStorageResponse {
-  duration: string;
-}
+  created_at?: Date;
 
-export interface DeleteMessageRequest {
-  hard_delete?: boolean;
-}
+  deactivated_at?: Date;
 
-export interface DeleteMessageResponse {
-  duration: string;
+  deleted_at?: Date;
 
-  message: MessageResponse;
-}
+  invisible?: boolean;
 
-export interface DeleteModerationConfigResponse {
-  duration: string;
-}
+  language?: string;
 
-export interface DeleteModerationTemplateResponse {
-  duration: string;
-}
+  last_active?: Date;
 
-export interface DeleteReactionRequest {
-  hard_delete?: boolean;
-}
+  last_engaged_at?: Date;
 
-export interface DeleteReactionResponse {
-  duration: string;
+  revoke_tokens_issued_before?: Date;
 
-  message: MessageResponse;
+  updated_at?: Date;
 
-  reaction: ReactionResponse;
-}
+  teams?: string[];
 
-export interface DeleteRecordingResponse {
-  duration: string;
+  privacy_settings?: PrivacySettings;
 }
 
-export interface DeleteReminderResponse {
-  duration: string;
-}
+export interface EntityCreatorResponse {
+  ban_count: number;
 
-export interface DeleteSegmentTargetsRequest {
-  target_ids: string[];
-}
+  banned: boolean;
 
-export interface DeleteTranscriptionResponse {
-  duration: string;
-}
+  created_at: Date;
 
-export interface DeleteUserRequest {
-  delete_conversation_channels?: boolean;
+  deleted_content_count: number;
 
-  delete_feeds_content?: boolean;
+  flagged_count: number;
 
-  hard_delete?: boolean;
+  id: string;
 
-  mark_messages_deleted?: boolean;
-}
+  invisible: boolean;
 
-export interface DeleteUsersRequest {
-  user_ids: string[];
+  language: string;
 
-  calls?: 'soft' | 'hard';
+  online: boolean;
 
-  conversations?: 'soft' | 'hard';
+  role: string;
 
-  messages?: 'soft' | 'pruning' | 'hard';
+  shadow_banned: boolean;
 
-  new_call_owner_id?: string;
+  updated_at: Date;
 
-  new_channel_owner_id?: string;
+  blocked_user_ids: string[];
 
-  user?: 'soft' | 'pruning' | 'hard';
-}
+  teams: string[];
 
-export interface DeleteUsersResponse {
-  duration: string;
+  custom: Record<string, any>;
 
-  task_id: string;
-}
+  ban_expires?: Date;
 
-export interface Device {
-  created_at: Date;
+  deactivated_at?: Date;
 
-  id: string;
+  deleted_at?: Date;
 
-  push_provider: 'firebase' | 'apn' | 'huawei' | 'xiaomi';
+  image?: string;
 
-  user_id: string;
+  last_active?: Date;
 
-  disabled?: boolean;
+  name?: string;
 
-  disabled_reason?: string;
+  revoke_tokens_issued_before?: Date;
 
-  push_provider_name?: string;
+  devices?: DeviceResponse[];
 
-  voip?: boolean;
-}
+  privacy_settings?: PrivacySettingsResponse;
 
-export interface DeviceDataResponse {
-  name?: string;
+  push_notifications?: PushNotificationSettingsResponse;
 
-  version?: string;
+  teams_role?: Record<string, string>;
 }
 
-export interface DeviceErrorInfo {
-  error_message: string;
+export interface ErrorResult {
+  type: string;
 
-  provider: string;
+  stacktrace?: string;
 
-  provider_name: string;
+  version?: string;
 }
 
-export interface DeviceResponse {
-  created_at: Date;
+export interface EventHook {
+  created_at?: Date;
 
-  id: string;
+  enabled?: boolean;
 
-  push_provider: string;
+  hook_type?: string;
 
-  user_id: string;
+  id?: string;
 
-  disabled?: boolean;
+  sns_auth_type?: string;
 
-  disabled_reason?: string;
+  sns_key?: string;
 
-  push_provider_name?: string;
+  sns_region?: string;
 
-  voip?: boolean;
-}
+  sns_role_arn?: string;
 
-export interface DraftPayloadResponse {
-  id: string;
+  sns_secret?: string;
 
-  text: string;
+  sns_topic_arn?: string;
 
-  custom: Record<string, any>;
+  sqs_auth_type?: string;
 
-  html?: string;
+  sqs_key?: string;
 
-  mml?: string;
+  sqs_queue_url?: string;
 
-  parent_id?: string;
+  sqs_region?: string;
 
-  poll_id?: string;
+  sqs_role_arn?: string;
 
-  quoted_message_id?: string;
+  sqs_secret?: string;
 
-  show_in_channel?: boolean;
+  timeout_ms?: number;
 
-  silent?: boolean;
+  updated_at?: Date;
 
-  type?: string;
+  webhook_url?: string;
 
-  attachments?: Attachment[];
+  event_types?: string[];
 
-  mentioned_users?: UserResponse[];
+  callback?: AsyncModerationCallbackConfig;
 }
 
-export interface DraftResponse {
-  channel_cid: string;
+export interface EventNotificationSettings {
+  enabled: boolean;
 
-  created_at: Date;
+  apns: APNS;
 
-  message: DraftPayloadResponse;
+  fcm: FCM;
+}
+
+export interface EventRequest {
+  type: string;
 
   parent_id?: string;
 
-  channel?: ChannelResponse;
+  user_id?: string;
 
-  parent_message?: MessageResponse;
+  custom?: Record<string, any>;
 
-  quoted_message?: MessageResponse;
+  user?: UserRequest;
 }
 
-export interface EdgeResponse {
-  continent_code: string;
-
-  country_iso_code: string;
-
-  green: number;
+export interface EventResponse {
+  duration: string;
 
-  id: string;
+  event: WSEvent;
+}
 
-  latency_test_url: string;
+export interface ExportChannelsRequest {
+  channels: ChannelExport[];
 
-  latitude: number;
+  clear_deleted_message_text?: boolean;
 
-  longitude: number;
+  export_users?: boolean;
 
-  red: number;
+  include_soft_deleted_channels?: boolean;
 
-  subdivision_iso_code: string;
+  include_truncated_messages?: boolean;
 
-  yellow: number;
+  version?: string;
 }
 
-export interface EgressHLSResponse {
-  playlist_url: string;
+export interface ExportChannelsResponse {
+  duration: string;
 
-  status: string;
+  task_id: string;
 }
 
-export interface EgressRTMPResponse {
-  name: string;
-
-  started_at: Date;
+export interface ExportFeedUserDataRequest {}
 
-  stream_key?: string;
+export interface ExportFeedUserDataResponse {
+  duration: string;
 
-  stream_url?: string;
+  task_id: string;
 }
 
-export interface EgressResponse {
-  broadcasting: boolean;
+export interface ExportUserResponse {
+  duration: string;
 
-  rtmps: EgressRTMPResponse[];
+  messages?: MessageResponse[];
 
-  frame_recording?: FrameRecordingResponse;
+  reactions?: ReactionResponse[];
 
-  hls?: EgressHLSResponse;
+  user?: UserResponse;
 }
 
-export interface EgressTaskConfig {
-  egress_user?: EgressUser;
+export interface ExportUsersRequest {
+  user_ids: string[];
+}
 
-  frame_recording_egress_config?: FrameRecordingEgressConfig;
+export interface ExportUsersResponse {
+  duration: string;
 
-  hls_egress_config?: HLSEgressConfig;
+  task_id: string;
+}
 
-  recording_egress_config?: RecordingEgressConfig;
+export interface ExternalStorage {
+  abs_account_name?: string;
 
-  rtmp_egress_config?: RTMPEgressConfig;
+  abs_client_id?: string;
 
-  stt_egress_config?: STTEgressConfig;
-}
+  abs_client_secret?: string;
 
-export interface EgressUser {
-  token?: string;
-}
+  abs_tenant_id?: string;
 
-export interface EndCallRequest {}
+  bucket?: string;
 
-export interface EndCallResponse {
-  duration: string;
-}
+  gcs_credentials?: string;
 
-export interface EnrichedActivity {
-  foreign_id?: string;
+  path?: string;
 
-  id?: string;
+  s3_api_key?: string;
 
-  score?: number;
+  s3_custom_endpoint?: string;
 
-  verb?: string;
+  s3_region?: string;
 
-  to?: string[];
+  s3_secret_key?: string;
 
-  actor?: Data;
+  storage_name?: string;
 
-  latest_reactions?: Record<string, EnrichedReaction[]>;
+  storage_type?: number;
+}
 
-  object?: Data;
+export interface ExternalStorageResponse {
+  bucket: string;
 
-  origin?: Data;
+  name: string;
 
-  own_reactions?: Record<string, EnrichedReaction[]>;
+  path: string;
 
-  reaction_counts?: Record<string, number>;
+  type: 's3' | 'gcs' | 'abs';
+}
 
-  target?: Data;
+export interface FCM {
+  data?: Record<string, any>;
 }
 
-export interface EnrichedReaction {
-  activity_id: string;
+export interface FeedCreatedEvent {
+  created_at: Date;
 
-  kind: string;
+  fid: string;
 
-  user_id: string;
+  members: FeedMemberResponse[];
 
-  id?: string;
+  custom: Record<string, any>;
 
-  parent?: string;
+  feed: FeedResponse;
 
-  target_feeds?: string[];
+  user: UserResponseCommonFields;
 
-  children_counts?: Record<string, number>;
+  type: string;
 
-  created_at?: Time;
+  received_at?: Date;
+}
 
-  data?: Record<string, any>;
+export interface FeedDeletedEvent {
+  created_at: Date;
 
-  latest_children?: Record<string, EnrichedReaction[]>;
+  fid: string;
 
-  own_children?: Record<string, EnrichedReaction[]>;
+  custom: Record<string, any>;
 
-  updated_at?: Time;
+  type: string;
 
-  user?: Data;
+  received_at?: Date;
+
+  user?: UserResponseCommonFields;
 }
 
-export interface EntityCreator {
-  ban_count: number;
+export interface FeedGroup {
+  app_pk: number;
 
-  banned: boolean;
+  created_at: Date;
 
-  deleted_content_count: number;
+  default_view_id: string;
 
-  id: string;
+  default_visibility: string;
 
-  online: boolean;
+  id: string;
 
-  role: string;
+  updated_at: Date;
 
   custom: Record<string, any>;
 
-  teams_role: Record<string, string>;
+  deleted_at?: Date;
 
-  ban_expires?: Date;
+  last_feed_get_at?: Date;
 
-  created_at?: Date;
+  notification?: NotificationConfig;
 
-  deactivated_at?: Date;
+  stories?: StoriesConfig;
+}
 
-  deleted_at?: Date;
+export interface FeedGroupChangedEvent {
+  created_at: Date;
 
-  invisible?: boolean;
+  fid: string;
 
-  language?: string;
+  custom: Record<string, any>;
 
-  last_active?: Date;
+  type: string;
 
-  last_engaged_at?: Date;
+  received_at?: Date;
 
-  revoke_tokens_issued_before?: Date;
+  feed_group?: FeedGroup;
 
-  updated_at?: Date;
+  user?: UserResponseCommonFields;
+}
 
-  teams?: string[];
+export interface FeedGroupDeletedEvent {
+  created_at: Date;
 
-  privacy_settings?: PrivacySettings;
-}
+  fid: string;
 
-export interface EntityCreatorResponse {
-  ban_count: number;
+  group_id: string;
 
-  banned: boolean;
+  custom: Record<string, any>;
 
-  created_at: Date;
+  type: string;
 
-  deleted_content_count: number;
+  received_at?: Date;
+}
 
-  flagged_count: number;
+export interface FeedGroupResponse {
+  created_at: Date;
 
   id: string;
 
-  invisible: boolean;
-
-  language: string;
+  updated_at: Date;
 
-  online: boolean;
+  default_view_id?: string;
 
-  role: string;
+  default_visibility?: string;
 
-  shadow_banned: boolean;
+  custom?: Record<string, any>;
 
-  updated_at: Date;
+  notification?: NotificationConfig;
 
-  blocked_user_ids: string[];
+  stories?: StoriesConfig;
+}
 
-  teams: string[];
+export interface FeedInput {
+  description?: string;
 
-  custom: Record<string, any>;
+  name?: string;
 
-  ban_expires?: Date;
+  visibility?: 'public' | 'visible' | 'followers' | 'members' | 'private';
 
-  deactivated_at?: Date;
+  filter_tags?: string[];
 
-  deleted_at?: Date;
+  members?: FeedMemberRequest[];
 
-  image?: string;
+  custom?: Record<string, any>;
+}
 
-  last_active?: Date;
+export interface FeedMemberAddedEvent {
+  created_at: Date;
 
-  name?: string;
+  fid: string;
 
-  revoke_tokens_issued_before?: Date;
+  custom: Record<string, any>;
 
-  devices?: DeviceResponse[];
+  member: FeedMemberResponse;
 
-  privacy_settings?: PrivacySettingsResponse;
+  type: string;
 
-  push_notifications?: PushNotificationSettingsResponse;
+  received_at?: Date;
 
-  teams_role?: Record<string, string>;
+  user?: UserResponseCommonFields;
 }
 
-export interface ErrorResult {
+export interface FeedMemberRemovedEvent {
+  created_at: Date;
+
+  fid: string;
+
+  member_id: string;
+
+  custom: Record<string, any>;
+
   type: string;
 
-  stacktrace?: string;
+  received_at?: Date;
 
-  version?: string;
+  user?: UserResponseCommonFields;
 }
 
-export interface EventHook {
-  created_at?: Date;
+export interface FeedMemberRequest {
+  user_id: string;
 
-  enabled?: boolean;
+  invite?: boolean;
 
-  hook_type?: string;
+  role?: string;
 
-  id?: string;
+  custom?: Record<string, any>;
+}
 
-  sns_auth_type?: string;
+export interface FeedMemberResponse {
+  created_at: Date;
 
-  sns_key?: string;
+  role: string;
 
-  sns_region?: string;
+  status: 'member' | 'pending' | 'rejected';
 
-  sns_role_arn?: string;
+  updated_at: Date;
 
-  sns_secret?: string;
+  user: UserResponse;
 
-  sns_topic_arn?: string;
+  invite_accepted_at?: Date;
 
-  sqs_auth_type?: string;
+  invite_rejected_at?: Date;
 
-  sqs_key?: string;
+  custom?: Record<string, any>;
+}
 
-  sqs_queue_url?: string;
+export interface FeedMemberUpdatedEvent {
+  created_at: Date;
 
-  sqs_region?: string;
+  fid: string;
 
-  sqs_role_arn?: string;
+  custom: Record<string, any>;
 
-  sqs_secret?: string;
+  member: FeedMemberResponse;
 
-  timeout_ms?: number;
+  type: string;
 
-  updated_at?: Date;
+  received_at?: Date;
 
-  webhook_url?: string;
+  user?: UserResponseCommonFields;
+}
 
-  event_types?: string[];
+export const FeedOwnCapability = {
+  ADD_ACTIVITY: 'add-activity',
+  ADD_ACTIVITY_REACTION: 'add-activity-reaction',
+  ADD_COMMENT: 'add-comment',
+  ADD_COMMENT_REACTION: 'add-comment-reaction',
+  BOOKMARK_ACTIVITY: 'bookmark-activity',
+  CREATE_FEED: 'create-feed',
+  DELETE_BOOKMARK: 'delete-bookmark',
+  DELETE_COMMENT: 'delete-comment',
+  DELETE_FEED: 'delete-feed',
+  EDIT_BOOKMARK: 'edit-bookmark',
+  FOLLOW: 'follow',
+  INVITE_FEED: 'invite-feed',
+  JOIN_FEED: 'join-feed',
+  LEAVE_FEED: 'leave-feed',
+  MANAGE_FEED_GROUP: 'manage-feed-group',
+  MARK_ACTIVITY: 'mark-activity',
+  PIN_ACTIVITY: 'pin-activity',
+  QUERY_FEED_MEMBERS: 'query-feed-members',
+  QUERY_FOLLOWS: 'query-follows',
+  READ_ACTIVITIES: 'read-activities',
+  READ_FEED: 'read-feed',
+  REMOVE_ACTIVITY: 'remove-activity',
+  REMOVE_ACTIVITY_REACTION: 'remove-activity-reaction',
+  REMOVE_COMMENT_REACTION: 'remove-comment-reaction',
+  UNFOLLOW: 'unfollow',
+  UPDATE_ACTIVITY: 'update-activity',
+  UPDATE_COMMENT: 'update-comment',
+  UPDATE_FEED: 'update-feed',
+  UPDATE_FEED_FOLLOWERS: 'update-feed-followers',
+  UPDATE_FEED_MEMBERS: 'update-feed-members',
+} as const;
 
-  callback?: AsyncModerationCallbackConfig;
-}
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type FeedOwnCapability =
+  (typeof FeedOwnCapability)[keyof typeof FeedOwnCapability];
 
-export interface EventNotificationSettings {
-  enabled: boolean;
+export interface FeedRequest {
+  feed_group_id: string;
 
-  apns: APNS;
+  feed_id: string;
+
+  created_by_id?: string;
+
+  description?: string;
 
-  fcm: FCM;
-}
+  name?: string;
 
-export interface EventRequest {
-  type: string;
+  visibility?: 'public' | 'visible' | 'followers' | 'members' | 'private';
 
-  parent_id?: string;
+  filter_tags?: string[];
 
-  user_id?: string;
+  members?: FeedMemberRequest[];
 
   custom?: Record<string, any>;
-
-  user?: UserRequest;
 }
 
-export interface EventResponse {
-  duration: string;
+export interface FeedResponse {
+  created_at: Date;
 
-  event: WSEvent;
-}
+  description: string;
 
-export interface ExportChannelsRequest {
-  channels: ChannelExport[];
+  fid: string;
 
-  clear_deleted_message_text?: boolean;
+  follower_count: number;
 
-  export_users?: boolean;
+  following_count: number;
 
-  include_soft_deleted_channels?: boolean;
+  group_id: string;
 
-  include_truncated_messages?: boolean;
+  id: string;
 
-  version?: string;
-}
+  member_count: number;
 
-export interface ExportChannelsResponse {
-  duration: string;
+  name: string;
 
-  task_id: string;
-}
+  pin_count: number;
 
-export interface ExportUserResponse {
-  duration: string;
+  updated_at: Date;
 
-  messages?: MessageResponse[];
+  created_by: UserResponse;
 
-  reactions?: ReactionResponse[];
+  deleted_at?: Date;
 
-  user?: UserResponse;
-}
+  visibility?: string;
 
-export interface ExportUsersRequest {
-  user_ids: string[];
+  filter_tags?: string[];
+
+  custom?: Record<string, any>;
 }
 
-export interface ExportUsersResponse {
-  duration: string;
+export interface FeedUpdatedEvent {
+  created_at: Date;
 
-  task_id: string;
-}
+  fid: string;
 
-export interface ExternalStorage {
-  abs_account_name?: string;
+  custom: Record<string, any>;
 
-  abs_client_id?: string;
+  feed: FeedResponse;
 
-  abs_client_secret?: string;
+  type: string;
 
-  abs_tenant_id?: string;
+  received_at?: Date;
 
-  bucket?: string;
+  user?: UserResponseCommonFields;
+}
 
-  gcs_credentials?: string;
+export interface FeedViewResponse {
+  view_id: string;
 
-  path?: string;
+  last_used_at?: Date;
 
-  s3_api_key?: string;
+  activity_processors?: ActivityProcessorConfig[];
 
-  s3_custom_endpoint?: string;
+  activity_selectors?: ActivitySelectorConfig[];
 
-  s3_region?: string;
+  aggregation?: AggregationConfig;
 
-  s3_secret_key?: string;
+  ranking?: RankingConfig;
+}
 
-  storage_name?: string;
+export interface FeedsModerationTemplateConfig {
+  config_key: string;
 
-  storage_type?: number;
+  data_types: Record<string, string>;
 }
 
-export interface ExternalStorageResponse {
-  bucket: string;
+export interface FeedsReactionResponse {
+  activity_id: string;
 
-  name: string;
+  created_at: Date;
 
-  path: string;
+  type: string;
 
-  type: 's3' | 'gcs' | 'abs';
-}
+  updated_at: Date;
 
-export interface FCM {
-  data?: Record<string, any>;
-}
+  user: UserResponse;
 
-export interface FeedsModerationTemplateConfig {
-  config_key: string;
+  comment_id?: string;
 
-  data_types: Record<string, string>;
+  custom?: Record<string, any>;
 }
 
 export interface Field {
@@ -4209,6 +5451,98 @@ export interface FlagUserOptions {
   reason: string;
 }
 
+export interface FollowBatchRequest {
+  follows: FollowRequest[];
+}
+
+export interface FollowBatchResponse {
+  duration: string;
+
+  follows: FollowResponse[];
+}
+
+export interface FollowCreatedEvent {
+  created_at: Date;
+
+  fid: string;
+
+  custom: Record<string, any>;
+
+  follow: FollowResponse;
+
+  type: string;
+
+  received_at?: Date;
+}
+
+export interface FollowDeletedEvent {
+  created_at: Date;
+
+  fid: string;
+
+  custom: Record<string, any>;
+
+  follow: FollowResponse;
+
+  type: string;
+
+  received_at?: Date;
+}
+
+export interface FollowPair {
+  source: string;
+
+  target: string;
+}
+
+export interface FollowRequest {
+  source: string;
+
+  target: string;
+
+  create_notification_activity?: boolean;
+
+  push_preference?: 'all' | 'none';
+
+  custom?: Record<string, any>;
+}
+
+export interface FollowResponse {
+  created_at: Date;
+
+  follower_role: string;
+
+  push_preference: 'all' | 'none';
+
+  status: 'accepted' | 'pending' | 'rejected';
+
+  updated_at: Date;
+
+  source_feed: FeedResponse;
+
+  target_feed: FeedResponse;
+
+  request_accepted_at?: Date;
+
+  request_rejected_at?: Date;
+
+  custom?: Record<string, any>;
+}
+
+export interface FollowUpdatedEvent {
+  created_at: Date;
+
+  fid: string;
+
+  custom: Record<string, any>;
+
+  follow: FollowResponse;
+
+  type: string;
+
+  received_at?: Date;
+}
+
 export interface FrameRecordSettings {
   capture_interval_in_seconds: number;
 
@@ -4341,6 +5675,12 @@ export interface GetActiveCallsStatusResponse {
   summary?: ActiveCallsSummary;
 }
 
+export interface GetActivityResponse {
+  duration: string;
+
+  activity: ActivityResponse;
+}
+
 export interface GetApplicationResponse {
   duration: string;
 
@@ -4495,6 +5835,32 @@ export interface GetCommandResponse {
   updated_at?: Date;
 }
 
+export interface GetCommentRepliesResponse {
+  duration: string;
+
+  comments: ThreadedCommentResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface GetCommentResponse {
+  duration: string;
+
+  comment: CommentResponse;
+}
+
+export interface GetCommentsResponse {
+  duration: string;
+
+  comments: ThreadedCommentResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
 export interface GetConfigResponse {
   duration: string;
 
@@ -4519,6 +5885,24 @@ export interface GetEdgesResponse {
   edges: EdgeResponse[];
 }
 
+export interface GetFeedGroupResponse {
+  duration: string;
+
+  feed_group: FeedGroupResponse;
+}
+
+export interface GetFeedViewResponse {
+  duration: string;
+
+  feed_view: FeedViewResponse;
+}
+
+export interface GetFollowSuggestionsResponse {
+  duration: string;
+
+  suggestions: FeedResponse[];
+}
+
 export interface GetImportResponse {
   duration: string;
 
@@ -4554,61 +5938,131 @@ export interface GetOGResponse {
 
   color?: string;
 
-  fallback?: string;
+  fallback?: string;
+
+  footer?: string;
+
+  footer_icon?: string;
+
+  image_url?: string;
+
+  og_scrape_url?: string;
+
+  original_height?: number;
+
+  original_width?: number;
+
+  pretext?: string;
+
+  text?: string;
+
+  thumb_url?: string;
+
+  title?: string;
+
+  title_link?: string;
+
+  type?: string;
+
+  actions?: Action[];
+
+  fields?: Field[];
+
+  giphy?: Images;
+}
+
+export interface GetOrCreateCallRequest {
+  members_limit?: number;
+
+  notify?: boolean;
+
+  ring?: boolean;
+
+  video?: boolean;
+
+  data?: CallRequest;
+}
+
+export interface GetOrCreateCallResponse {
+  created: boolean;
+
+  duration: string;
+
+  members: MemberResponse[];
+
+  own_capabilities: OwnCapability[];
+
+  call: CallResponse;
+}
+
+export interface GetOrCreateFeedRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  user_id?: string;
+
+  view?: string;
+
+  watch?: boolean;
+
+  activity_selector_options?: Record<string, any>;
+
+  data?: FeedInput;
 
-  footer?: string;
+  external_ranking?: Record<string, any>;
 
-  footer_icon?: string;
+  filter?: Record<string, any>;
 
-  image_url?: string;
+  followers_pagination?: PagerRequest;
 
-  og_scrape_url?: string;
+  following_pagination?: PagerRequest;
 
-  original_height?: number;
+  interest_weights?: Record<string, number>;
 
-  original_width?: number;
+  member_pagination?: PagerRequest;
 
-  pretext?: string;
+  user?: UserRequest;
+}
 
-  text?: string;
+export interface GetOrCreateFeedResponse {
+  created: boolean;
 
-  thumb_url?: string;
+  duration: string;
 
-  title?: string;
+  activities: ActivityResponse[];
 
-  title_link?: string;
+  aggregated_activities: AggregatedActivityResponse[];
 
-  type?: string;
+  followers: FollowResponse[];
 
-  actions?: Action[];
+  following: FollowResponse[];
 
-  fields?: Field[];
+  members: FeedMemberResponse[];
 
-  giphy?: Images;
-}
+  own_capabilities: FeedOwnCapability[];
 
-export interface GetOrCreateCallRequest {
-  members_limit?: number;
+  pinned_activities: ActivityPinResponse[];
 
-  notify?: boolean;
+  feed: FeedResponse;
 
-  ring?: boolean;
+  next?: string;
 
-  video?: boolean;
+  prev?: string;
 
-  data?: CallRequest;
-}
+  own_follows?: FollowResponse[];
 
-export interface GetOrCreateCallResponse {
-  created: boolean;
+  followers_pagination?: PagerResponse;
 
-  duration: string;
+  following_pagination?: PagerResponse;
 
-  members: MemberResponse[];
+  member_pagination?: PagerResponse;
 
-  own_capabilities: OwnCapability[];
+  notification_status?: NotificationStatusResponse;
 
-  call: CallResponse;
+  own_membership?: FeedMemberResponse;
 }
 
 export interface GetPushTemplatesResponse {
@@ -5005,6 +6459,18 @@ export interface ListExternalStorageResponse {
   external_storages: Record<string, ExternalStorageResponse>;
 }
 
+export interface ListFeedGroupsResponse {
+  duration: string;
+
+  groups: Record<string, FeedGroupResponse>;
+}
+
+export interface ListFeedViewsResponse {
+  duration: string;
+
+  views: Record<string, FeedViewResponse>;
+}
+
 export interface ListImportsResponse {
   duration: string;
 
@@ -5041,6 +6507,20 @@ export interface ListTranscriptionsResponse {
   transcriptions: CallTranscription[];
 }
 
+export interface MarkActivityRequest {
+  mark_all_read?: boolean;
+
+  mark_all_seen?: boolean;
+
+  user_id?: string;
+
+  mark_read?: string[];
+
+  mark_watched?: string[];
+
+  user?: UserRequest;
+}
+
 export interface MarkChannelsReadRequest {
   user_id?: string;
 
@@ -5959,6 +7439,12 @@ export interface NoiseCancellationSettings {
   mode: 'available' | 'disabled' | 'auto-on';
 }
 
+export interface NotificationConfig {
+  track_read?: boolean;
+
+  track_seen?: boolean;
+}
+
 export interface NotificationMarkUnreadEvent {
   channel_id: string;
 
@@ -6011,6 +7497,16 @@ export interface NotificationSettings {
   session_started: EventNotificationSettings;
 }
 
+export interface NotificationStatusResponse {
+  unread: number;
+
+  unseen: number;
+
+  last_seen_at?: Date;
+
+  read_activities?: string[];
+}
+
 export interface NullTime {}
 
 export interface OCRRule {
@@ -6181,6 +7677,14 @@ export interface OwnUserResponse {
   total_unread_count_by_team?: Record<string, number>;
 }
 
+export interface PagerRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+}
+
 export interface PagerResponse {
   next?: string;
 
@@ -6301,6 +7805,24 @@ export interface PermissionRequestEvent {
   type: string;
 }
 
+export interface PinActivityRequest {
+  user_id?: string;
+
+  user?: UserRequest;
+}
+
+export interface PinActivityResponse {
+  created_at: Date;
+
+  duration: string;
+
+  fid: string;
+
+  user_id: string;
+
+  activity: ActivityResponse;
+}
+
 export interface PinRequest {
   session_id: string;
 
@@ -6783,6 +8305,50 @@ export interface QualityScoreReportResponse {
   daily: DailyAggregateQualityScoreReportResponse[];
 }
 
+export interface QueryActivitiesRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryActivitiesResponse {
+  duration: string;
+
+  activities: ActivityResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryActivityReactionsRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryActivityReactionsResponse {
+  duration: string;
+
+  reactions: FeedsReactionResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
 export interface QueryAggregateCallStatsRequest {
   from?: string;
 
@@ -6831,6 +8397,50 @@ export interface QueryBannedUsersResponse {
   bans: BanResponse[];
 }
 
+export interface QueryBookmarkFoldersRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryBookmarkFoldersResponse {
+  duration: string;
+
+  bookmark_folders: BookmarkFolderResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryBookmarksRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryBookmarksResponse {
+  duration: string;
+
+  bookmarks: BookmarkResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
 export interface QueryCallMembersRequest {
   id: string;
 
@@ -6969,46 +8579,158 @@ export interface QueryChannelsResponse {
   channels: ChannelStateResponseFields[];
 }
 
-export interface QueryDraftsRequest {
+export interface QueryCommentReactionsRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryCommentReactionsResponse {
+  duration: string;
+
+  reactions: FeedsReactionResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryCommentsRequest {
+  filter: Record<string, any>;
+
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: 'first' | 'last' | 'top' | 'best' | 'controversial';
+}
+
+export interface QueryCommentsResponse {
+  duration: string;
+
+  comments: CommentResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryDraftsRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  user_id?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+
+  user?: UserRequest;
+}
+
+export interface QueryDraftsResponse {
+  duration: string;
+
+  drafts: DraftResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryFeedMembersRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryFeedMembersResponse {
+  duration: string;
+
+  members: FeedMemberResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
+export interface QueryFeedModerationTemplate {
+  created_at: Date;
+
+  name: string;
+
+  updated_at: Date;
+
+  config?: FeedsModerationTemplateConfig;
+}
+
+export interface QueryFeedModerationTemplatesResponse {
+  duration: string;
+
+  templates: QueryFeedModerationTemplate[];
+}
+
+export interface QueryFeedsRequest {
   limit?: number;
 
   next?: string;
 
   prev?: string;
 
-  user_id?: string;
+  watch?: boolean;
 
   sort?: SortParamRequest[];
 
   filter?: Record<string, any>;
-
-  user?: UserRequest;
 }
 
-export interface QueryDraftsResponse {
+export interface QueryFeedsResponse {
   duration: string;
 
-  drafts: DraftResponse[];
+  feeds: FeedResponse[];
 
   next?: string;
 
   prev?: string;
 }
 
-export interface QueryFeedModerationTemplate {
-  created_at: Date;
+export interface QueryFollowsRequest {
+  limit?: number;
 
-  name: string;
+  next?: string;
 
-  updated_at: Date;
+  prev?: string;
 
-  config?: FeedsModerationTemplateConfig;
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
 }
 
-export interface QueryFeedModerationTemplatesResponse {
+export interface QueryFollowsResponse {
   duration: string;
 
-  templates: QueryFeedModerationTemplate[];
+  follows: FollowResponse[];
+
+  next?: string;
+
+  prev?: string;
 }
 
 export interface QueryMembersPayload {
@@ -7473,6 +9195,16 @@ export interface RTMPSettingsResponse {
   layout: LayoutSettingsResponse;
 }
 
+export interface RankingConfig {
+  score?: string;
+
+  type?: string;
+
+  defaults?: Record<string, any>;
+
+  functions?: Record<string, DecayFunctionConfig>;
+}
+
 export interface Reaction {
   created_at: Date;
 
@@ -7701,6 +9433,30 @@ export interface RecordingEgressConfig {
   video_orientation_hint?: VideoOrientation;
 }
 
+export interface RejectFeedMemberInviteRequest {
+  user_id?: string;
+
+  user?: UserRequest;
+}
+
+export interface RejectFeedMemberInviteResponse {
+  duration: string;
+
+  member: FeedMemberResponse;
+}
+
+export interface RejectFollowRequest {
+  source_fid: string;
+
+  target_fid: string;
+}
+
+export interface RejectFollowResponse {
+  duration: string;
+
+  follow: FollowResponse;
+}
+
 export interface ReminderResponseData {
   channel_cid: string;
 
@@ -7721,6 +9477,16 @@ export interface ReminderResponseData {
   user?: User;
 }
 
+export interface RepliesMeta {
+  depth_truncated: boolean;
+
+  has_more: boolean;
+
+  remaining: number;
+
+  next_cursor?: string;
+}
+
 export interface ReportByHistogramBucket {
   category: string;
 
@@ -8441,6 +10207,24 @@ export interface ShowChannelResponse {
   duration: string;
 }
 
+export interface SingleFollowRequest {
+  source: string;
+
+  target: string;
+
+  create_notification_activity?: boolean;
+
+  push_preference?: 'all' | 'none';
+
+  custom?: Record<string, any>;
+}
+
+export interface SingleFollowResponse {
+  duration: string;
+
+  follow: FollowResponse;
+}
+
 export interface SortParam {
   direction?: number;
 
@@ -8663,6 +10447,12 @@ export interface StopTranscriptionResponse {
   duration: string;
 }
 
+export interface StoriesConfig {
+  expiration_behaviour?: string;
+
+  skip_watched?: boolean;
+}
+
 export interface SubmitActionRequest {
   action_type:
     | 'mark_reviewed'
@@ -8888,6 +10678,60 @@ export interface ThreadUpdatedEvent {
   user?: User;
 }
 
+export interface ThreadedCommentResponse {
+  confidence_score: number;
+
+  created_at: Date;
+
+  downvote_count: number;
+
+  id: string;
+
+  object_id: string;
+
+  object_type: string;
+
+  reaction_count: number;
+
+  reply_count: number;
+
+  score: number;
+
+  status: string;
+
+  updated_at: Date;
+
+  upvote_count: number;
+
+  mentioned_users: UserResponse[];
+
+  own_reactions: FeedsReactionResponse[];
+
+  user: UserResponse;
+
+  controversy_score?: number;
+
+  deleted_at?: Date;
+
+  parent_id?: string;
+
+  text?: string;
+
+  attachments?: Attachment[];
+
+  latest_reactions?: FeedsReactionResponse[];
+
+  replies?: ThreadedCommentResponse[];
+
+  custom?: Record<string, any>;
+
+  meta?: RepliesMeta;
+
+  moderation?: ModerationV2Response;
+
+  reaction_groups?: Record<string, ReactionGroupResponse>;
+}
+
 export interface Thresholds {
   explicit?: LabelThresholds;
 
@@ -9192,6 +11036,18 @@ export interface UnblockedUserEvent {
   type: string;
 }
 
+export interface UnfollowBatchRequest {
+  follows: FollowPair[];
+}
+
+export interface UnfollowBatchResponse {
+  duration: string;
+}
+
+export interface UnfollowResponse {
+  duration: string;
+}
+
 export interface UnmuteChannelRequest {
   expiration?: number;
 
@@ -9216,6 +11072,16 @@ export interface UnmuteResponse {
   non_existing_users?: string[];
 }
 
+export interface UnpinActivityResponse {
+  duration: string;
+
+  fid: string;
+
+  user_id: string;
+
+  activity: ActivityResponse;
+}
+
 export interface UnpinRequest {
   session_id: string;
 
@@ -9276,6 +11142,52 @@ export interface UnreadCountsThread {
   unread_count: number;
 }
 
+export interface UpdateActivityPartialRequest {
+  user_id?: string;
+
+  unset?: string[];
+
+  set?: Record<string, any>;
+
+  user?: UserRequest;
+}
+
+export interface UpdateActivityPartialResponse {
+  duration: string;
+
+  activity: ActivityResponse;
+}
+
+export interface UpdateActivityRequest {
+  expires_at?: Date;
+
+  poll_id?: string;
+
+  text?: string;
+
+  user_id?: string;
+
+  visibility?: string;
+
+  attachments?: Attachment[];
+
+  filter_tags?: string[];
+
+  interest_tags?: string[];
+
+  custom?: Record<string, any>;
+
+  location?: ActivityLocation;
+
+  user?: UserRequest;
+}
+
+export interface UpdateActivityResponse {
+  duration: string;
+
+  activity: ActivityResponse;
+}
+
 export interface UpdateAppRequest {
   async_url_enrich_enabled?: boolean;
 
@@ -9380,6 +11292,42 @@ export interface UpdateBlockListResponse {
   blocklist?: BlockListResponse;
 }
 
+export interface UpdateBookmarkFolderRequest {
+  name?: string;
+
+  user_id?: string;
+
+  custom?: Record<string, any>;
+
+  user?: UserRequest;
+}
+
+export interface UpdateBookmarkFolderResponse {
+  duration: string;
+
+  bookmark_folder: BookmarkFolderResponse;
+}
+
+export interface UpdateBookmarkRequest {
+  folder_id?: string;
+
+  new_folder_id?: string;
+
+  user_id?: string;
+
+  custom?: Record<string, any>;
+
+  new_folder?: AddFolderRequest;
+
+  user?: UserRequest;
+}
+
+export interface UpdateBookmarkResponse {
+  duration: string;
+
+  bookmark: BookmarkResponse;
+}
+
 export interface UpdateCallMembersRequest {
   remove_members?: string[];
 
@@ -9648,6 +11596,18 @@ export interface UpdateCommandResponse {
   command?: Command;
 }
 
+export interface UpdateCommentRequest {
+  comment?: string;
+
+  custom?: Record<string, any>;
+}
+
+export interface UpdateCommentResponse {
+  duration: string;
+
+  comment: CommentResponse;
+}
+
 export interface UpdateExternalStorageRequest {
   bucket: string;
 
@@ -9674,6 +11634,90 @@ export interface UpdateExternalStorageResponse {
   type: 's3' | 'gcs' | 'abs';
 }
 
+export interface UpdateFeedGroupRequest {
+  default_view_id?: string;
+
+  custom?: Record<string, any>;
+
+  notification?: NotificationConfig;
+}
+
+export interface UpdateFeedGroupResponse {
+  duration: string;
+
+  feed_group: FeedGroupResponse;
+}
+
+export interface UpdateFeedMembersRequest {
+  operation: 'upsert' | 'remove' | 'set';
+
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  members?: FeedMemberRequest[];
+}
+
+export interface UpdateFeedMembersResponse {
+  duration: string;
+
+  added: FeedMemberResponse[];
+
+  removed_ids: string[];
+
+  updated: FeedMemberResponse[];
+}
+
+export interface UpdateFeedRequest {
+  created_by_id?: string;
+
+  custom?: Record<string, any>;
+}
+
+export interface UpdateFeedResponse {
+  duration: string;
+
+  feed: FeedResponse;
+}
+
+export interface UpdateFeedViewRequest {
+  activity_processors?: ActivityProcessorConfig[];
+
+  activity_selectors?: ActivitySelectorConfig[];
+
+  aggregation?: AggregationConfig;
+
+  ranking?: RankingConfig;
+}
+
+export interface UpdateFeedViewResponse {
+  duration: string;
+
+  feed_view: FeedViewResponse;
+}
+
+export interface UpdateFollowRequest {
+  source: string;
+
+  target: string;
+
+  create_notification_activity?: boolean;
+
+  follower_role?: string;
+
+  push_preference?: 'all' | 'none';
+
+  custom?: Record<string, any>;
+}
+
+export interface UpdateFollowResponse {
+  duration: string;
+
+  follow: FollowResponse;
+}
+
 export interface UpdateLiveLocationRequest {
   created_by_device_id: string;
 
@@ -9862,6 +11906,16 @@ export interface UpdatedCallPermissionsEvent {
   type: string;
 }
 
+export interface UpsertActivitiesRequest {
+  activities: ActivityRequest[];
+}
+
+export interface UpsertActivitiesResponse {
+  duration: string;
+
+  activities: ActivityResponse[];
+}
+
 export interface UpsertConfigRequest {
   key: string;
 
@@ -10481,8 +12535,6 @@ export interface VoteData {
   answer_text?: string;
 
   option_id?: string;
-
-  option?: PollOptionResponseData;
 }
 
 export interface WSEvent {
@@ -10541,9 +12593,162 @@ export interface WSEvent {
   user?: UserResponse;
 }
 
-export interface WebhookEvent {
-  type: string;
-}
+export type WebhookEvent =
+  | ({ type: '*' } & AnyEvent)
+  | ({ type: 'activity.marked' } & ActivityMarkedEvent)
+  | ({ type: 'call.accepted' } & CallAcceptedEvent)
+  | ({ type: 'call.blocked_user' } & BlockedUserEvent)
+  | ({ type: 'call.closed_caption' } & ClosedCaptionEvent)
+  | ({ type: 'call.closed_captions_failed' } & CallClosedCaptionsFailedEvent)
+  | ({ type: 'call.closed_captions_started' } & CallClosedCaptionsStartedEvent)
+  | ({ type: 'call.closed_captions_stopped' } & CallClosedCaptionsStoppedEvent)
+  | ({ type: 'call.created' } & CallCreatedEvent)
+  | ({ type: 'call.deleted' } & CallDeletedEvent)
+  | ({ type: 'call.ended' } & CallEndedEvent)
+  | ({ type: 'call.frame_recording_failed' } & CallFrameRecordingFailedEvent)
+  | ({ type: 'call.frame_recording_ready' } & CallFrameRecordingFrameReadyEvent)
+  | ({ type: 'call.frame_recording_started' } & CallFrameRecordingStartedEvent)
+  | ({ type: 'call.frame_recording_stopped' } & CallFrameRecordingStoppedEvent)
+  | ({ type: 'call.hls_broadcasting_failed' } & CallHLSBroadcastingFailedEvent)
+  | ({
+      type: 'call.hls_broadcasting_started';
+    } & CallHLSBroadcastingStartedEvent)
+  | ({
+      type: 'call.hls_broadcasting_stopped';
+    } & CallHLSBroadcastingStoppedEvent)
+  | ({ type: 'call.live_started' } & CallLiveStartedEvent)
+  | ({ type: 'call.member_added' } & CallMemberAddedEvent)
+  | ({ type: 'call.member_removed' } & CallMemberRemovedEvent)
+  | ({ type: 'call.member_updated' } & CallMemberUpdatedEvent)
+  | ({
+      type: 'call.member_updated_permission';
+    } & CallMemberUpdatedPermissionEvent)
+  | ({ type: 'call.missed' } & CallMissedEvent)
+  | ({ type: 'call.moderation_blur' } & CallModerationBlurEvent)
+  | ({ type: 'call.moderation_warning' } & CallModerationWarningEvent)
+  | ({ type: 'call.notification' } & CallNotificationEvent)
+  | ({ type: 'call.permission_request' } & PermissionRequestEvent)
+  | ({ type: 'call.permissions_updated' } & UpdatedCallPermissionsEvent)
+  | ({ type: 'call.reaction_new' } & CallReactionEvent)
+  | ({ type: 'call.recording_failed' } & CallRecordingFailedEvent)
+  | ({ type: 'call.recording_ready' } & CallRecordingReadyEvent)
+  | ({ type: 'call.recording_started' } & CallRecordingStartedEvent)
+  | ({ type: 'call.recording_stopped' } & CallRecordingStoppedEvent)
+  | ({ type: 'call.rejected' } & CallRejectedEvent)
+  | ({ type: 'call.ring' } & CallRingEvent)
+  | ({ type: 'call.rtmp_broadcast_failed' } & CallRtmpBroadcastFailedEvent)
+  | ({ type: 'call.rtmp_broadcast_started' } & CallRtmpBroadcastStartedEvent)
+  | ({ type: 'call.rtmp_broadcast_stopped' } & CallRtmpBroadcastStoppedEvent)
+  | ({ type: 'call.session_ended' } & CallSessionEndedEvent)
+  | ({
+      type: 'call.session_participant_joined';
+    } & CallSessionParticipantJoinedEvent)
+  | ({
+      type: 'call.session_participant_left';
+    } & CallSessionParticipantLeftEvent)
+  | ({ type: 'call.session_started' } & CallSessionStartedEvent)
+  | ({ type: 'call.stats_report_ready' } & CallStatsReportReadyEvent)
+  | ({ type: 'call.transcription_failed' } & CallTranscriptionFailedEvent)
+  | ({ type: 'call.transcription_ready' } & CallTranscriptionReadyEvent)
+  | ({ type: 'call.transcription_started' } & CallTranscriptionStartedEvent)
+  | ({ type: 'call.transcription_stopped' } & CallTranscriptionStoppedEvent)
+  | ({ type: 'call.unblocked_user' } & UnblockedUserEvent)
+  | ({ type: 'call.updated' } & CallUpdatedEvent)
+  | ({ type: 'call.user_feedback_submitted' } & CallUserFeedbackSubmittedEvent)
+  | ({ type: 'call.user_muted' } & CallUserMutedEvent)
+  | ({ type: 'campaign.completed' } & CampaignCompletedEvent)
+  | ({ type: 'campaign.started' } & CampaignStartedEvent)
+  | ({ type: 'channel.created' } & ChannelCreatedEvent)
+  | ({ type: 'channel.deleted' } & ChannelDeletedEvent)
+  | ({ type: 'channel.frozen' } & ChannelFrozenEvent)
+  | ({ type: 'channel.hidden' } & ChannelHiddenEvent)
+  | ({ type: 'channel.muted' } & ChannelMutedEvent)
+  | ({ type: 'channel.truncated' } & ChannelTruncatedEvent)
+  | ({ type: 'channel.unfrozen' } & ChannelUnFrozenEvent)
+  | ({ type: 'channel.unmuted' } & ChannelUnmutedEvent)
+  | ({ type: 'channel.updated' } & ChannelUpdatedEvent)
+  | ({ type: 'channel.visible' } & ChannelVisibleEvent)
+  | ({ type: 'custom' } & CustomVideoEvent)
+  | ({ type: 'export.bulk_image_moderation.error' } & AsyncExportErrorEvent)
+  | ({
+      type: 'export.bulk_image_moderation.success';
+    } & AsyncBulkImageModerationEvent)
+  | ({ type: 'export.channels.error' } & AsyncExportErrorEvent)
+  | ({ type: 'export.channels.success' } & AsyncExportChannelsEvent)
+  | ({ type: 'export.moderation_logs.error' } & AsyncExportErrorEvent)
+  | ({
+      type: 'export.moderation_logs.success';
+    } & AsyncExportModerationLogsEvent)
+  | ({ type: 'export.users.error' } & AsyncExportErrorEvent)
+  | ({ type: 'export.users.success' } & AsyncExportUsersEvent)
+  | ({ type: 'feeds.activity.added' } & ActivityAddedEvent)
+  | ({ type: 'feeds.activity.deleted' } & ActivityDeletedEvent)
+  | ({ type: 'feeds.activity.marked' } & ActivityMarkEvent)
+  | ({ type: 'feeds.activity.pinned' } & ActivityPinnedEvent)
+  | ({ type: 'feeds.activity.reaction.added' } & ActivityReactionAddedEvent)
+  | ({ type: 'feeds.activity.reaction.deleted' } & ActivityReactionDeletedEvent)
+  | ({ type: 'feeds.activity.reaction.updated' } & ActivityReactionUpdatedEvent)
+  | ({
+      type: 'feeds.activity.removed_from_feed';
+    } & ActivityRemovedFromFeedEvent)
+  | ({ type: 'feeds.activity.unpinned' } & ActivityUnpinnedEvent)
+  | ({ type: 'feeds.activity.updated' } & ActivityUpdatedEvent)
+  | ({ type: 'feeds.bookmark.added' } & BookmarkAddedEvent)
+  | ({ type: 'feeds.bookmark.deleted' } & BookmarkDeletedEvent)
+  | ({ type: 'feeds.bookmark.updated' } & BookmarkUpdatedEvent)
+  | ({ type: 'feeds.bookmark_folder.deleted' } & BookmarkFolderDeletedEvent)
+  | ({ type: 'feeds.bookmark_folder.updated' } & BookmarkFolderUpdatedEvent)
+  | ({ type: 'feeds.comment.added' } & CommentAddedEvent)
+  | ({ type: 'feeds.comment.deleted' } & CommentDeletedEvent)
+  | ({ type: 'feeds.comment.reaction.added' } & CommentReactionAddedEvent)
+  | ({ type: 'feeds.comment.reaction.deleted' } & CommentReactionDeletedEvent)
+  | ({ type: 'feeds.comment.reaction.updated' } & CommentReactionUpdatedEvent)
+  | ({ type: 'feeds.comment.updated' } & CommentUpdatedEvent)
+  | ({ type: 'feeds.feed.created' } & FeedCreatedEvent)
+  | ({ type: 'feeds.feed.deleted' } & FeedDeletedEvent)
+  | ({ type: 'feeds.feed.updated' } & FeedUpdatedEvent)
+  | ({ type: 'feeds.feed_group.changed' } & FeedGroupChangedEvent)
+  | ({ type: 'feeds.feed_group.deleted' } & FeedGroupDeletedEvent)
+  | ({ type: 'feeds.feed_member.added' } & FeedMemberAddedEvent)
+  | ({ type: 'feeds.feed_member.removed' } & FeedMemberRemovedEvent)
+  | ({ type: 'feeds.feed_member.updated' } & FeedMemberUpdatedEvent)
+  | ({ type: 'feeds.follow.created' } & FollowCreatedEvent)
+  | ({ type: 'feeds.follow.deleted' } & FollowDeletedEvent)
+  | ({ type: 'feeds.follow.updated' } & FollowUpdatedEvent)
+  | ({ type: 'flag.updated' } & FlagUpdatedEvent)
+  | ({ type: 'member.added' } & MemberAddedEvent)
+  | ({ type: 'member.removed' } & MemberRemovedEvent)
+  | ({ type: 'member.updated' } & MemberUpdatedEvent)
+  | ({ type: 'message.deleted' } & MessageDeletedEvent)
+  | ({ type: 'message.flagged' } & MessageFlaggedEvent)
+  | ({ type: 'message.new' } & MessageNewEvent)
+  | ({ type: 'message.pending' } & PendingMessageEvent)
+  | ({ type: 'message.read' } & MessageReadEvent)
+  | ({ type: 'message.unblocked' } & MessageUnblockedEvent)
+  | ({ type: 'message.undeleted' } & MessageUndeletedEvent)
+  | ({ type: 'message.updated' } & MessageUpdatedEvent)
+  | ({ type: 'moderation.custom_action' } & ModerationCustomActionEvent)
+  | ({ type: 'moderation.flagged' } & ModerationFlaggedEvent)
+  | ({ type: 'moderation.mark_reviewed' } & ModerationMarkReviewedEvent)
+  | ({ type: 'moderation_check.completed' } & ModerationCheckCompletedEvent)
+  | ({ type: 'notification.mark_unread' } & NotificationMarkUnreadEvent)
+  | ({ type: 'notification.thread_message_new' } & MessageNewEvent)
+  | ({ type: 'reaction.deleted' } & ReactionDeletedEvent)
+  | ({ type: 'reaction.new' } & ReactionNewEvent)
+  | ({ type: 'reaction.updated' } & ReactionUpdatedEvent)
+  | ({ type: 'review_queue_item.new' } & ReviewQueueItemNewEvent)
+  | ({ type: 'review_queue_item.updated' } & ReviewQueueItemUpdatedEvent)
+  | ({ type: 'thread.updated' } & ThreadUpdatedEvent)
+  | ({ type: 'user.banned' } & UserBannedEvent)
+  | ({ type: 'user.deactivated' } & UserDeactivatedEvent)
+  | ({ type: 'user.deleted' } & UserDeletedEvent)
+  | ({ type: 'user.flagged' } & UserFlaggedEvent)
+  | ({ type: 'user.muted' } & UserMutedEvent)
+  | ({ type: 'user.reactivated' } & UserReactivatedEvent)
+  | ({ type: 'user.unbanned' } & UserUnbannedEvent)
+  | ({ type: 'user.unmuted' } & UserUnmutedEvent)
+  | ({ type: 'user.unread_message_reminder' } & UserUnreadReminderEvent)
+  | ({ type: 'user.updated' } & UserUpdatedEvent);
 
 export interface WrappedUnreadCountsResponse {
   duration: string;
diff --git a/src/gen/moderation/ModerationApi.ts b/src/gen/moderation/ModerationApi.ts
index 228bee4..96957c2 100644
--- a/src/gen/moderation/ModerationApi.ts
+++ b/src/gen/moderation/ModerationApi.ts
@@ -1,5 +1,4 @@
-import { BaseApi } from '../../BaseApi';
-import { StreamResponse } from '../../types';
+import { ApiClient, StreamResponse } from '../../gen-imports';
 import {
   BanRequest,
   BanResponse,
@@ -37,10 +36,12 @@ import {
   UpsertModerationTemplateRequest,
   UpsertModerationTemplateResponse,
 } from '../models';
-import { decoders } from '../model-decoders';
+import { decoders } from '../model-decoders/decoders';
 
-export class ModerationApi extends BaseApi {
-  ban = async (request: BanRequest): Promise<StreamResponse<BanResponse>> => {
+export class ModerationApi {
+  constructor(public readonly apiClient: ApiClient) {}
+
+  async ban(request: BanRequest): Promise<StreamResponse<BanResponse>> {
     const body = {
       target_user_id: request?.target_user_id,
       banned_by_id: request?.banned_by_id,
@@ -53,27 +54,30 @@ export class ModerationApi extends BaseApi {
       banned_by: request?.banned_by,
     };
 
-    const response = await this.sendRequest<StreamResponse<BanResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<BanResponse>
+    >(
       'POST',
       '/api/v2/moderation/ban',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.BanResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  bulkImageModeration = async (
+  async bulkImageModeration(
     request: BulkImageModerationRequest,
-  ): Promise<StreamResponse<BulkImageModerationResponse>> => {
+  ): Promise<StreamResponse<BulkImageModerationResponse>> {
     const body = {
       csv_file: request?.csv_file,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<BulkImageModerationResponse>
     >(
       'POST',
@@ -81,16 +85,15 @@ export class ModerationApi extends BaseApi {
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.BulkImageModerationResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  check = async (
-    request: CheckRequest,
-  ): Promise<StreamResponse<CheckResponse>> => {
+  async check(request: CheckRequest): Promise<StreamResponse<CheckResponse>> {
     const body = {
       config_key: request?.config_key,
       entity_creator_id: request?.entity_creator_id,
@@ -104,22 +107,25 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<CheckResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CheckResponse>
+    >(
       'POST',
       '/api/v2/moderation/check',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.CheckResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  upsertConfig = async (
+  async upsertConfig(
     request: UpsertConfigRequest,
-  ): Promise<StreamResponse<UpsertConfigResponse>> => {
+  ): Promise<StreamResponse<UpsertConfigResponse>> {
     const body = {
       key: request?.key,
       async: request?.async,
@@ -142,19 +148,26 @@ export class ModerationApi extends BaseApi {
       video_call_rule_config: request?.video_call_rule_config,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpsertConfigResponse>
-    >('POST', '/api/v2/moderation/config', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/config',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.UpsertConfigResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  deleteConfig = async (request: {
+  async deleteConfig(request: {
     key: string;
     team?: string;
-  }): Promise<StreamResponse<DeleteModerationConfigResponse>> => {
+  }): Promise<StreamResponse<DeleteModerationConfigResponse>> {
     const queryParams = {
       team: request?.team,
     };
@@ -162,19 +175,19 @@ export class ModerationApi extends BaseApi {
       key: request?.key,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteModerationConfigResponse>
     >('DELETE', '/api/v2/moderation/config/{key}', pathParams, queryParams);
 
     decoders.DeleteModerationConfigResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getConfig = async (request: {
+  async getConfig(request: {
     key: string;
     team?: string;
-  }): Promise<StreamResponse<GetConfigResponse>> => {
+  }): Promise<StreamResponse<GetConfigResponse>> {
     const queryParams = {
       team: request?.team,
     };
@@ -182,21 +195,18 @@ export class ModerationApi extends BaseApi {
       key: request?.key,
     };
 
-    const response = await this.sendRequest<StreamResponse<GetConfigResponse>>(
-      'GET',
-      '/api/v2/moderation/config/{key}',
-      pathParams,
-      queryParams,
-    );
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetConfigResponse>
+    >('GET', '/api/v2/moderation/config/{key}', pathParams, queryParams);
 
     decoders.GetConfigResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryModerationConfigs = async (
+  async queryModerationConfigs(
     request?: QueryModerationConfigsRequest,
-  ): Promise<StreamResponse<QueryModerationConfigsResponse>> => {
+  ): Promise<StreamResponse<QueryModerationConfigsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -207,18 +217,25 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryModerationConfigsResponse>
-    >('POST', '/api/v2/moderation/configs', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/configs',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryModerationConfigsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  customCheck = async (
+  async customCheck(
     request: CustomCheckRequest,
-  ): Promise<StreamResponse<CustomCheckResponse>> => {
+  ): Promise<StreamResponse<CustomCheckResponse>> {
     const body = {
       entity_id: request?.entity_id,
       entity_type: request?.entity_type,
@@ -229,19 +246,26 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<CustomCheckResponse>
-    >('POST', '/api/v2/moderation/custom_check', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/custom_check',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.CustomCheckResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  v2DeleteTemplate = async (): Promise<
+  async v2DeleteTemplate(): Promise<
     StreamResponse<DeleteModerationTemplateResponse>
-  > => {
-    const response = await this.sendRequest<
+  > {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<DeleteModerationTemplateResponse>
     >(
       'DELETE',
@@ -253,12 +277,12 @@ export class ModerationApi extends BaseApi {
     decoders.DeleteModerationTemplateResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  v2QueryTemplates = async (): Promise<
+  async v2QueryTemplates(): Promise<
     StreamResponse<QueryFeedModerationTemplatesResponse>
-  > => {
-    const response = await this.sendRequest<
+  > {
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryFeedModerationTemplatesResponse>
     >(
       'GET',
@@ -270,17 +294,17 @@ export class ModerationApi extends BaseApi {
     decoders.QueryFeedModerationTemplatesResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  v2UpsertTemplate = async (
+  async v2UpsertTemplate(
     request: UpsertModerationTemplateRequest,
-  ): Promise<StreamResponse<UpsertModerationTemplateResponse>> => {
+  ): Promise<StreamResponse<UpsertModerationTemplateResponse>> {
     const body = {
       name: request?.name,
       config: request?.config,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<UpsertModerationTemplateResponse>
     >(
       'POST',
@@ -288,16 +312,15 @@ export class ModerationApi extends BaseApi {
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UpsertModerationTemplateResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  flag = async (
-    request: FlagRequest,
-  ): Promise<StreamResponse<FlagResponse>> => {
+  async flag(request: FlagRequest): Promise<StreamResponse<FlagResponse>> {
     const body = {
       entity_id: request?.entity_id,
       entity_type: request?.entity_type,
@@ -309,22 +332,25 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<FlagResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<FlagResponse>
+    >(
       'POST',
       '/api/v2/moderation/flag',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.FlagResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryModerationFlags = async (
+  async queryModerationFlags(
     request?: QueryModerationFlagsRequest,
-  ): Promise<StreamResponse<QueryModerationFlagsResponse>> => {
+  ): Promise<StreamResponse<QueryModerationFlagsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -333,18 +359,25 @@ export class ModerationApi extends BaseApi {
       filter: request?.filter,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryModerationFlagsResponse>
-    >('POST', '/api/v2/moderation/flags', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/flags',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryModerationFlagsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryModerationLogs = async (
+  async queryModerationLogs(
     request?: QueryModerationLogsRequest,
-  ): Promise<StreamResponse<QueryModerationLogsResponse>> => {
+  ): Promise<StreamResponse<QueryModerationLogsResponse>> {
     const body = {
       limit: request?.limit,
       next: request?.next,
@@ -355,18 +388,23 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryModerationLogsResponse>
-    >('POST', '/api/v2/moderation/logs', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/logs',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryModerationLogsResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  mute = async (
-    request: MuteRequest,
-  ): Promise<StreamResponse<MuteResponse>> => {
+  async mute(request: MuteRequest): Promise<StreamResponse<MuteResponse>> {
     const body = {
       target_ids: request?.target_ids,
       timeout: request?.timeout,
@@ -374,22 +412,25 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<MuteResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<MuteResponse>
+    >(
       'POST',
       '/api/v2/moderation/mute',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.MuteResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  queryReviewQueue = async (
+  async queryReviewQueue(
     request?: QueryReviewQueueRequest,
-  ): Promise<StreamResponse<QueryReviewQueueResponse>> => {
+  ): Promise<StreamResponse<QueryReviewQueueResponse>> {
     const body = {
       limit: request?.limit,
       lock_count: request?.lock_count,
@@ -404,34 +445,41 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<QueryReviewQueueResponse>
-    >('POST', '/api/v2/moderation/review_queue', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/review_queue',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.QueryReviewQueueResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  getReviewQueueItem = async (request: {
+  async getReviewQueueItem(request: {
     id: string;
-  }): Promise<StreamResponse<GetReviewQueueItemResponse>> => {
+  }): Promise<StreamResponse<GetReviewQueueItemResponse>> {
     const pathParams = {
       id: request?.id,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<GetReviewQueueItemResponse>
     >('GET', '/api/v2/moderation/review_queue/{id}', pathParams, undefined);
 
     decoders.GetReviewQueueItemResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  submitAction = async (
+  async submitAction(
     request: SubmitActionRequest,
-  ): Promise<StreamResponse<SubmitActionResponse>> => {
+  ): Promise<StreamResponse<SubmitActionResponse>> {
     const body = {
       action_type: request?.action_type,
       item_id: request?.item_id,
@@ -447,22 +495,29 @@ export class ModerationApi extends BaseApi {
       user: request?.user,
     };
 
-    const response = await this.sendRequest<
+    const response = await this.apiClient.sendRequest<
       StreamResponse<SubmitActionResponse>
-    >('POST', '/api/v2/moderation/submit_action', undefined, undefined, body);
+    >(
+      'POST',
+      '/api/v2/moderation/submit_action',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
 
     decoders.SubmitActionResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unban = async (
+  async unban(
     request: UnbanRequest & {
       target_user_id: string;
       channel_cid?: string;
       created_by?: string;
     },
-  ): Promise<StreamResponse<UnbanResponse>> => {
+  ): Promise<StreamResponse<UnbanResponse>> {
     const queryParams = {
       target_user_id: request?.target_user_id,
       channel_cid: request?.channel_cid,
@@ -473,38 +528,44 @@ export class ModerationApi extends BaseApi {
       unbanned_by: request?.unbanned_by,
     };
 
-    const response = await this.sendRequest<StreamResponse<UnbanResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnbanResponse>
+    >(
       'POST',
       '/api/v2/moderation/unban',
       undefined,
       queryParams,
       body,
+      'application/json',
     );
 
     decoders.UnbanResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 
-  unmute = async (
+  async unmute(
     request: UnmuteRequest,
-  ): Promise<StreamResponse<UnmuteResponse>> => {
+  ): Promise<StreamResponse<UnmuteResponse>> {
     const body = {
       target_ids: request?.target_ids,
       user_id: request?.user_id,
       user: request?.user,
     };
 
-    const response = await this.sendRequest<StreamResponse<UnmuteResponse>>(
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UnmuteResponse>
+    >(
       'POST',
       '/api/v2/moderation/unmute',
       undefined,
       undefined,
       body,
+      'application/json',
     );
 
     decoders.UnmuteResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
-  };
+  }
 }
diff --git a/src/gen/video/CallApi.ts b/src/gen/video/CallApi.ts
index 0a7960e..d1f3943 100644
--- a/src/gen/video/CallApi.ts
+++ b/src/gen/video/CallApi.ts
@@ -1,5 +1,4 @@
-import { VideoApi } from './VideoApi';
-import { StreamResponse } from '../../types';
+import { StreamResponse, VideoApi } from '../../gen-imports';
 import {
   BlockUserRequest,
   BlockUserResponse,
@@ -68,305 +67,295 @@ export class CallApi {
     public readonly id: string,
   ) {}
 
-  get = (request?: {
+  get(request?: {
     members_limit?: number;
     ring?: boolean;
     notify?: boolean;
     video?: boolean;
-  }): Promise<StreamResponse<GetCallResponse>> => {
+  }): Promise<StreamResponse<GetCallResponse>> {
     return this.videoApi.getCall({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  update = (
+  update(
     request?: UpdateCallRequest,
-  ): Promise<StreamResponse<UpdateCallResponse>> => {
+  ): Promise<StreamResponse<UpdateCallResponse>> {
     return this.videoApi.updateCall({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  getOrCreate = (
+  getOrCreate(
     request?: GetOrCreateCallRequest,
-  ): Promise<StreamResponse<GetOrCreateCallResponse>> => {
+  ): Promise<StreamResponse<GetOrCreateCallResponse>> {
     return this.videoApi.getOrCreateCall({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  blockUser = (
+  blockUser(
     request: BlockUserRequest,
-  ): Promise<StreamResponse<BlockUserResponse>> => {
+  ): Promise<StreamResponse<BlockUserResponse>> {
     return this.videoApi.blockUser({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  delete = (
+  delete(
     request?: DeleteCallRequest,
-  ): Promise<StreamResponse<DeleteCallResponse>> => {
+  ): Promise<StreamResponse<DeleteCallResponse>> {
     return this.videoApi.deleteCall({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  sendCallEvent = (
+  sendCallEvent(
     request?: SendCallEventRequest,
-  ): Promise<StreamResponse<SendCallEventResponse>> => {
+  ): Promise<StreamResponse<SendCallEventResponse>> {
     return this.videoApi.sendCallEvent({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  collectUserFeedback = (
+  collectUserFeedback(
     request: CollectUserFeedbackRequest,
-  ): Promise<StreamResponse<CollectUserFeedbackResponse>> => {
+  ): Promise<StreamResponse<CollectUserFeedbackResponse>> {
     return this.videoApi.collectUserFeedback({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  goLive = (
-    request?: GoLiveRequest,
-  ): Promise<StreamResponse<GoLiveResponse>> => {
+  goLive(request?: GoLiveRequest): Promise<StreamResponse<GoLiveResponse>> {
     return this.videoApi.goLive({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  end = (): Promise<StreamResponse<EndCallResponse>> => {
+  end(): Promise<StreamResponse<EndCallResponse>> {
     return this.videoApi.endCall({ id: this.id, type: this.type });
-  };
+  }
 
-  updateCallMembers = (
+  updateCallMembers(
     request?: UpdateCallMembersRequest,
-  ): Promise<StreamResponse<UpdateCallMembersResponse>> => {
+  ): Promise<StreamResponse<UpdateCallMembersResponse>> {
     return this.videoApi.updateCallMembers({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  muteUsers = (
+  muteUsers(
     request?: MuteUsersRequest,
-  ): Promise<StreamResponse<MuteUsersResponse>> => {
+  ): Promise<StreamResponse<MuteUsersResponse>> {
     return this.videoApi.muteUsers({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  queryCallParticipants = (
+  queryCallParticipants(
     request?: QueryCallParticipantsRequest & { limit?: number },
-  ): Promise<StreamResponse<QueryCallParticipantsResponse>> => {
+  ): Promise<StreamResponse<QueryCallParticipantsResponse>> {
     return this.videoApi.queryCallParticipants({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  videoPin = (request: PinRequest): Promise<StreamResponse<PinResponse>> => {
+  videoPin(request: PinRequest): Promise<StreamResponse<PinResponse>> {
     return this.videoApi.videoPin({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  listRecordings = (): Promise<StreamResponse<ListRecordingsResponse>> => {
+  listRecordings(): Promise<StreamResponse<ListRecordingsResponse>> {
     return this.videoApi.listRecordings({ id: this.id, type: this.type });
-  };
+  }
 
-  getCallReport = (request?: {
+  getCallReport(request?: {
     session_id?: string;
-  }): Promise<StreamResponse<GetCallReportResponse>> => {
+  }): Promise<StreamResponse<GetCallReportResponse>> {
     return this.videoApi.getCallReport({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  startRTMPBroadcasts = (
+  startRTMPBroadcasts(
     request: StartRTMPBroadcastsRequest,
-  ): Promise<StreamResponse<StartRTMPBroadcastsResponse>> => {
+  ): Promise<StreamResponse<StartRTMPBroadcastsResponse>> {
     return this.videoApi.startRTMPBroadcasts({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  stopAllRTMPBroadcasts = (): Promise<
+  stopAllRTMPBroadcasts(): Promise<
     StreamResponse<StopAllRTMPBroadcastsResponse>
-  > => {
+  > {
     return this.videoApi.stopAllRTMPBroadcasts({
       id: this.id,
       type: this.type,
     });
-  };
+  }
 
-  stopRTMPBroadcast = (
+  stopRTMPBroadcast(
     request: StopRTMPBroadcastsRequest & { name: string },
-  ): Promise<StreamResponse<StopRTMPBroadcastsResponse>> => {
+  ): Promise<StreamResponse<StopRTMPBroadcastsResponse>> {
     return this.videoApi.stopRTMPBroadcast({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  startHLSBroadcasting = (): Promise<
+  startHLSBroadcasting(): Promise<
     StreamResponse<StartHLSBroadcastingResponse>
-  > => {
+  > {
     return this.videoApi.startHLSBroadcasting({ id: this.id, type: this.type });
-  };
+  }
 
-  startClosedCaptions = (
+  startClosedCaptions(
     request?: StartClosedCaptionsRequest,
-  ): Promise<StreamResponse<StartClosedCaptionsResponse>> => {
+  ): Promise<StreamResponse<StartClosedCaptionsResponse>> {
     return this.videoApi.startClosedCaptions({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  startFrameRecording = (
+  startFrameRecording(
     request?: StartFrameRecordingRequest,
-  ): Promise<StreamResponse<StartFrameRecordingResponse>> => {
+  ): Promise<StreamResponse<StartFrameRecordingResponse>> {
     return this.videoApi.startFrameRecording({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  startRecording = (
+  startRecording(
     request?: StartRecordingRequest,
-  ): Promise<StreamResponse<StartRecordingResponse>> => {
+  ): Promise<StreamResponse<StartRecordingResponse>> {
     return this.videoApi.startRecording({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  startTranscription = (
+  startTranscription(
     request?: StartTranscriptionRequest,
-  ): Promise<StreamResponse<StartTranscriptionResponse>> => {
+  ): Promise<StreamResponse<StartTranscriptionResponse>> {
     return this.videoApi.startTranscription({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  stopHLSBroadcasting = (): Promise<
-    StreamResponse<StopHLSBroadcastingResponse>
-  > => {
+  stopHLSBroadcasting(): Promise<StreamResponse<StopHLSBroadcastingResponse>> {
     return this.videoApi.stopHLSBroadcasting({ id: this.id, type: this.type });
-  };
+  }
 
-  stopClosedCaptions = (
+  stopClosedCaptions(
     request?: StopClosedCaptionsRequest,
-  ): Promise<StreamResponse<StopClosedCaptionsResponse>> => {
+  ): Promise<StreamResponse<StopClosedCaptionsResponse>> {
     return this.videoApi.stopClosedCaptions({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  stopFrameRecording = (): Promise<
-    StreamResponse<StopFrameRecordingResponse>
-  > => {
+  stopFrameRecording(): Promise<StreamResponse<StopFrameRecordingResponse>> {
     return this.videoApi.stopFrameRecording({ id: this.id, type: this.type });
-  };
+  }
 
-  stopLive = (
+  stopLive(
     request?: StopLiveRequest,
-  ): Promise<StreamResponse<StopLiveResponse>> => {
+  ): Promise<StreamResponse<StopLiveResponse>> {
     return this.videoApi.stopLive({ id: this.id, type: this.type, ...request });
-  };
+  }
 
-  stopRecording = (): Promise<StreamResponse<StopRecordingResponse>> => {
+  stopRecording(): Promise<StreamResponse<StopRecordingResponse>> {
     return this.videoApi.stopRecording({ id: this.id, type: this.type });
-  };
+  }
 
-  stopTranscription = (
+  stopTranscription(
     request?: StopTranscriptionRequest,
-  ): Promise<StreamResponse<StopTranscriptionResponse>> => {
+  ): Promise<StreamResponse<StopTranscriptionResponse>> {
     return this.videoApi.stopTranscription({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  listTranscriptions = (): Promise<
-    StreamResponse<ListTranscriptionsResponse>
-  > => {
+  listTranscriptions(): Promise<StreamResponse<ListTranscriptionsResponse>> {
     return this.videoApi.listTranscriptions({ id: this.id, type: this.type });
-  };
+  }
 
-  unblockUser = (
+  unblockUser(
     request: UnblockUserRequest,
-  ): Promise<StreamResponse<UnblockUserResponse>> => {
+  ): Promise<StreamResponse<UnblockUserResponse>> {
     return this.videoApi.unblockUser({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  videoUnpin = (
-    request: UnpinRequest,
-  ): Promise<StreamResponse<UnpinResponse>> => {
+  videoUnpin(request: UnpinRequest): Promise<StreamResponse<UnpinResponse>> {
     return this.videoApi.videoUnpin({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  updateUserPermissions = (
+  updateUserPermissions(
     request: UpdateUserPermissionsRequest,
-  ): Promise<StreamResponse<UpdateUserPermissionsResponse>> => {
+  ): Promise<StreamResponse<UpdateUserPermissionsResponse>> {
     return this.videoApi.updateUserPermissions({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  deleteRecording = (request: {
+  deleteRecording(request: {
     session: string;
     filename: string;
-  }): Promise<StreamResponse<DeleteRecordingResponse>> => {
+  }): Promise<StreamResponse<DeleteRecordingResponse>> {
     return this.videoApi.deleteRecording({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  deleteTranscription = (request: {
+  deleteTranscription(request: {
     session: string;
     filename: string;
-  }): Promise<StreamResponse<DeleteTranscriptionResponse>> => {
+  }): Promise<StreamResponse<DeleteTranscriptionResponse>> {
     return this.videoApi.deleteTranscription({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 }
diff --git a/src/gen/video/VideoApi.ts b/src/gen/video/VideoApi.ts
index e03b051..835064e 100644
--- a/src/gen/video/VideoApi.ts
+++ b/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 };
-  };
+  }
 }