diff --git a/src/channel.ts b/src/channel.ts
index 63b64ccddc..ca9cffab33 100644
--- a/src/channel.ts
+++ b/src/channel.ts
@@ -53,6 +53,7 @@ import {
   UserFilters,
   UserResponse,
   QueryChannelAPIResponse,
+  PollVoteData,
   SendMessageOptions,
 } from './types';
 import { Role } from './permissions';
@@ -1158,6 +1159,20 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
     return await this.getClient().post<CreateCallResponse>(this._channelURL() + '/call', options);
   }
 
+  /**
+   * Cast or cancel one or more votes on a poll
+   * @param pollId string The poll id
+   * @param votes PollVoteData[] The votes that will be casted (or canceled in case of an empty array)
+   * @returns {APIResponse & PollVoteResponse} The poll votes
+   */
+  async vote(messageId: string, pollId: string, vote: PollVoteData) {
+    return await this.getClient().castPollVote(messageId, pollId, vote);
+  }
+
+  async removeVote(messageId: string, pollId: string, voteId: string) {
+    return await this.getClient().removePollVote(messageId, pollId, voteId);
+  }
+
   /**
    * on - Listen to events on this channel.
    *
@@ -1401,6 +1416,31 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
           };
         }
         break;
+      case 'poll.updated':
+        if (event.poll) {
+          channelState.updatePoll(event.poll, event.message?.id || '');
+        }
+        break;
+      case 'poll.vote_casted':
+        if (event.poll_vote && event.poll) {
+          channelState.addPollVote(event.poll_vote, event.poll, event.message?.id || '');
+        }
+        break;
+      case 'poll.vote_changed':
+        if (event.poll_vote && event.poll) {
+          channelState.updatePollVote(event.poll_vote, event.poll, event.message?.id || '');
+        }
+        break;
+      case 'poll.vote_removed':
+        if (event.poll_vote && event.poll) {
+          channelState.removePollVote(event.poll_vote, event.poll, event.message?.id || '');
+        }
+        break;
+      case 'poll.closed':
+        if (event.message) {
+          channelState.addMessageSorted(event.message, false, false);
+        }
+        break;
       case 'reaction.new':
         if (event.message && event.reaction) {
           event.message = channelState.addReaction(event.reaction, event.message);
diff --git a/src/channel_state.ts b/src/channel_state.ts
index e7574979df..0e573986c5 100644
--- a/src/channel_state.ts
+++ b/src/channel_state.ts
@@ -11,6 +11,8 @@ import {
   ReactionResponse,
   UserResponse,
   PendingMessageResponse,
+  PollVote,
+  PollResponse,
 } from './types';
 import { addToMessageList } from './utils';
 
@@ -486,6 +488,96 @@ export class ChannelState<StreamChatGenerics extends ExtendableGenerics = Defaul
     return { removed: result.length < msgArray.length, result };
   };
 
+  // this handles the case when vote on poll is changed
+  updatePollVote = (
+    pollVote: PollVote<StreamChatGenerics>,
+    poll: PollResponse<StreamChatGenerics>,
+    messageId: string,
+  ) => {
+    const message = this.findMessage(messageId);
+    if (!message) return;
+
+    if (message.poll_id !== pollVote.poll_id) return;
+
+    const updatedPoll = { ...poll };
+    let ownVotes = [...(message.poll.own_votes || [])];
+
+    if (pollVote.user_id === this._channel.getClient().userID) {
+      if (pollVote.option_id && poll.enforce_unique_vote) {
+        // remove all previous votes where option_id is not empty
+        ownVotes = ownVotes.filter((vote) => !vote.option_id);
+      } else if (pollVote.answer_text) {
+        // remove all previous votes where option_id is empty
+        ownVotes = ownVotes.filter((vote) => vote.answer_text);
+      }
+
+      ownVotes.push(pollVote);
+    }
+
+    updatedPoll.own_votes = ownVotes as PollVote<StreamChatGenerics>[];
+    const newMessage = { ...message, poll: updatedPoll };
+
+    this.addMessageSorted((newMessage as unknown) as MessageResponse<StreamChatGenerics>, false, false);
+  };
+
+  addPollVote = (pollVote: PollVote<StreamChatGenerics>, poll: PollResponse<StreamChatGenerics>, messageId: string) => {
+    const message = this.findMessage(messageId);
+    if (!message) return;
+
+    if (message.poll_id !== pollVote.poll_id) return;
+
+    const updatedPoll = { ...poll };
+    const ownVotes = [...(message.poll.own_votes || [])];
+
+    if (pollVote.user_id === this._channel.getClient().userID) {
+      ownVotes.push(pollVote);
+    }
+
+    updatedPoll.own_votes = ownVotes as PollVote<StreamChatGenerics>[];
+    const newMessage = { ...message, poll: updatedPoll };
+
+    this.addMessageSorted((newMessage as unknown) as MessageResponse<StreamChatGenerics>, false, false);
+  };
+
+  removePollVote = (
+    pollVote: PollVote<StreamChatGenerics>,
+    poll: PollResponse<StreamChatGenerics>,
+    messageId: string,
+  ) => {
+    const message = this.findMessage(messageId);
+    if (!message) return;
+
+    if (message.poll_id !== pollVote.poll_id) return;
+
+    const updatedPoll = { ...poll };
+    const ownVotes = [...(message.poll.own_votes || [])];
+    if (pollVote.user_id === this._channel.getClient().userID) {
+      const index = ownVotes.findIndex((vote) => vote.option_id === pollVote.option_id);
+      if (index > -1) {
+        ownVotes.splice(index, 1);
+      }
+    }
+
+    updatedPoll.own_votes = ownVotes as PollVote<StreamChatGenerics>[];
+
+    const newMessage = { ...message, poll: updatedPoll };
+    this.addMessageSorted((newMessage as unknown) as MessageResponse<StreamChatGenerics>, false, false);
+  };
+
+  updatePoll = (poll: PollResponse<StreamChatGenerics>, messageId: string) => {
+    const message = this.findMessage(messageId);
+    if (!message) return;
+
+    const updatedPoll = {
+      ...poll,
+      own_votes: [...(message.poll?.own_votes || [])],
+    };
+
+    const newMessage = { ...message, poll: updatedPoll };
+
+    this.addMessageSorted((newMessage as unknown) as MessageResponse<StreamChatGenerics>, false, false);
+  };
+
   /**
    * Updates the message.user property with updated user object, for messages.
    *
diff --git a/src/client.ts b/src/client.ts
index c194298c33..67e5a72188 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -117,9 +117,14 @@ import {
   OGAttachment,
   OwnUserResponse,
   PartialMessageUpdate,
+  PartialPollUpdate,
   PartialUserUpdate,
   PermissionAPIResponse,
   PermissionsAPIResponse,
+  PollData,
+  PollOptionData,
+  PollVoteData,
+  PollVotesAPIResponse,
   PushProvider,
   PushProviderConfig,
   PushProviderID,
@@ -127,6 +132,7 @@ import {
   PushProviderUpsertResponse,
   QueryChannelsAPIResponse,
   QuerySegmentsOptions,
+  QueryPollsResponse,
   ReactionResponse,
   ReactivateUserOptions,
   ReactivateUsersOptions,
@@ -173,6 +179,20 @@ import {
   QuerySegmentTargetsFilter,
   SortParam,
   GetMessageOptions,
+  QueryVotesFilters,
+  VoteSort,
+  CreatePollAPIResponse,
+  GetPollAPIResponse,
+  UpdatePollAPIResponse,
+  CreatePollOptionAPIResponse,
+  GetPollOptionAPIResponse,
+  UpdatePollOptionAPIResponse,
+  PollVote,
+  CastVoteAPIResponse,
+  QueryPollsFilters,
+  PollSort,
+  QueryPollsOptions,
+  QueryVotesOptions,
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
 import { Thread } from './thread';
@@ -3406,4 +3426,190 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
   async commitMessage(id: string) {
     return await this.post<APIResponse & MessageResponse>(this.baseURL + `/messages/${id}/commit`);
   }
+
+  /**
+   * Creates a poll
+   * @param params PollData The poll that will be created
+   * @returns {APIResponse & CreatePollAPIResponse} The poll
+   */
+  async createPoll(poll: PollData) {
+    return await this.post<APIResponse & CreatePollAPIResponse>(this.baseURL + `/polls`, poll);
+  }
+
+  /**
+   * Retrieves a poll
+   * @param id string The poll id
+   * @returns {APIResponse & GetPollAPIResponse} The poll
+   */
+  async getPoll(id: string, userId?: string): Promise<APIResponse & GetPollAPIResponse> {
+    return await this.get<APIResponse & GetPollAPIResponse>(this.baseURL + `/polls/${id}`, {
+      ...(userId ? { user_id: userId } : {}),
+    });
+  }
+
+  /**
+   * Updates a poll
+   * @param poll PollData The poll that will be updated
+   * @returns {APIResponse & PollResponse} The poll
+   */
+  async updatePoll(poll: PollData) {
+    return await this.put<APIResponse & UpdatePollAPIResponse>(this.baseURL + `/polls`, poll);
+  }
+
+  /**
+   * Partially updates a poll
+   * @param id string The poll id
+   * @param {PartialPollUpdate<StreamChatGenerics>} partialPollObject which should contain id and any of "set" or "unset" params;
+   * example: {id: "44f26af5-f2be-4fa7-9dac-71cf893781de", set:{field: value}, unset:["field2"]}
+   * @returns {APIResponse & UpdatePollAPIResponse} The poll
+   */
+  async partialUpdatePoll(
+    id: string,
+    partialPollObject: PartialPollUpdate,
+  ): Promise<APIResponse & UpdatePollAPIResponse> {
+    return await this.patch<APIResponse & UpdatePollAPIResponse>(this.baseURL + `/polls/${id}`, partialPollObject);
+  }
+
+  /**
+   * Delete a poll
+   * @param id string The poll id
+   * @param userId string The user id (only serverside)
+   * @returns
+   */
+  async deletePoll(id: string, userId?: string): Promise<APIResponse> {
+    return await this.delete<APIResponse>(this.baseURL + `/polls/${id}`, {
+      ...(userId ? { user_id: userId } : {}),
+    });
+  }
+
+  /**
+   * Close a poll
+   * @param id string The poll id
+   * @returns {APIResponse & UpdatePollAPIResponse} The poll
+   */
+  async closePoll(id: string): Promise<APIResponse & UpdatePollAPIResponse> {
+    return this.partialUpdatePoll(id, {
+      set: {
+        is_closed: true,
+      },
+    });
+  }
+
+  /**
+   * Creates a poll option
+   * @param pollId string The poll id
+   * @param option PollOptionData The poll option that will be created
+   * @returns {APIResponse & PollOptionResponse} The poll option
+   */
+  async createPollOption(pollId: string, option: PollOptionData) {
+    return await this.post<APIResponse & CreatePollOptionAPIResponse>(
+      this.baseURL + `/polls/${pollId}/options`,
+      option,
+    );
+  }
+
+  /**
+   * Retrieves a poll option
+   * @param pollId string The poll id
+   * @param optionId string The poll option id
+   * @returns {APIResponse & PollOptionResponse} The poll option
+   */
+  async getPollOption(pollId: string, optionId: string) {
+    return await this.get<APIResponse & GetPollOptionAPIResponse>(
+      this.baseURL + `/polls/${pollId}/options/${optionId}`,
+    );
+  }
+
+  /**
+   * Updates a poll option
+   * @param pollId string The poll id
+   * @param option PollOptionData The poll option that will be updated
+   * @returns
+   */
+  async updatePollOption(pollId: string, option: PollOptionData) {
+    return await this.put<APIResponse & UpdatePollOptionAPIResponse>(this.baseURL + `/polls/${pollId}/options`, option);
+  }
+
+  /**
+   * Delete a poll option
+   * @param pollId string The poll id
+   * @param optionId string The poll option id
+   * @returns {APIResponse} The poll option
+   */
+  async deletePollOption(pollId: string, optionId: string) {
+    return await this.delete<APIResponse>(this.baseURL + `/polls/${pollId}/options/${optionId}`);
+  }
+
+  /**
+   * Cast vote on a poll
+   * @param messageId string The message id
+   * @param pollId string The poll id
+   * @param vote PollVoteData The vote that will be casted
+   * @returns {APIResponse & CastVoteAPIResponse} The poll vote
+   */
+  async castPollVote(messageId: string, pollId: string, vote: PollVoteData, options = {}) {
+    return await this.post<APIResponse & CastVoteAPIResponse>(
+      this.baseURL + `/messages/${messageId}/polls/${pollId}/vote`,
+      { vote, ...options },
+    );
+  }
+
+  /**
+   * Add a poll answer
+   * @param messageId string The message id
+   * @param pollId string The poll id
+   * @param answerText string The answer text
+   */
+  async addPollAnswer(messageId: string, pollId: string, answerText: string) {
+    return this.castPollVote(messageId, pollId, {
+      answer_text: answerText,
+    });
+  }
+
+  async removePollVote(messageId: string, pollId: string, voteId: string) {
+    return await this.delete<APIResponse & { vote: PollVote }>(
+      this.baseURL + `/messages/${messageId}/polls/${pollId}/vote/${voteId}`,
+    );
+  }
+
+  /**
+   * Queries polls
+   * @param filter
+   * @param sort
+   * @param options Option object, {limit: 10, offset:0}
+   * @returns {APIResponse & QueryPollsResponse} The polls
+   */
+  async queryPolls(
+    filter: QueryPollsFilters = {},
+    sort: PollSort = [],
+    options: QueryPollsOptions = {},
+  ): Promise<APIResponse & QueryPollsResponse> {
+    return await this.post<APIResponse & QueryPollsResponse>(this.baseURL + '/polls/query', {
+      filter,
+      sort: normalizeQuerySort(sort),
+      ...options,
+    });
+  }
+
+  /**
+   * Queries poll votes
+   * @param pollId
+   * @param filter
+   * @param sort
+   * @param options Option object, {limit: 10, offset:0}
+
+   * @returns {APIResponse & PollVotesAPIResponse} The poll votes
+   */
+  async queryPollVotes(
+    pollId: string,
+    filter: QueryVotesFilters = {},
+    sort: VoteSort = [],
+    options: QueryVotesOptions = {},
+  ): Promise<APIResponse & PollVotesAPIResponse> {
+    return await this.post<APIResponse & PollVotesAPIResponse>(this.baseURL + `/polls/${pollId}/votes`, {
+      filter,
+      sort: normalizeQuerySort(sort),
+      ...options,
+    });
+  }
 }
diff --git a/src/events.ts b/src/events.ts
index c0a762deef..2bb1f54824 100644
--- a/src/events.ts
+++ b/src/events.ts
@@ -30,6 +30,11 @@ export const EVENT_MAP = {
   'notification.mutes_updated': true,
   'notification.removed_from_channel': true,
   'notification.thread_message_new': true,
+  'poll.closed': true,
+  'poll.updated': true,
+  'poll.vote_casted': true,
+  'poll.vote_changed': true,
+  'poll.vote_removed': true,
   'reaction.deleted': true,
   'reaction.new': true,
   'reaction.updated': true,
diff --git a/src/thread.ts b/src/thread.ts
index 788651357b..1cc402093d 100644
--- a/src/thread.ts
+++ b/src/thread.ts
@@ -31,24 +31,38 @@ export class Thread<StreamChatGenerics extends ExtendableGenerics = DefaultGener
   replyCount = 0;
   _client: StreamChat<StreamChatGenerics>;
   read: ThreadReadStatus<StreamChatGenerics> = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: Record<string, any> = {};
 
   constructor(client: StreamChat<StreamChatGenerics>, t: ThreadResponse<StreamChatGenerics>) {
-    this.id = t.parent_message.id;
-    this.message = formatMessage(t.parent_message);
-    this.latestReplies = t.latest_replies.map(formatMessage);
-    this.participants = t.thread_participants;
-    this.replyCount = t.reply_count;
-    this.channel = t.channel;
+    const {
+      parent_message_id,
+      parent_message,
+      latest_replies,
+      thread_participants,
+      reply_count,
+      channel,
+      read,
+      ...data
+    } = t;
+
+    this.id = parent_message_id;
+    this.message = formatMessage(parent_message);
+    this.latestReplies = latest_replies.map(formatMessage);
+    this.participants = thread_participants;
+    this.replyCount = reply_count;
+    this.channel = channel;
     this._channel = client.channel(t.channel.type, t.channel.id);
     this._client = client;
-    if (t.read) {
-      for (const r of t.read) {
+    if (read) {
+      for (const r of read) {
         this.read[r.user.id] = {
           ...r,
           last_read: new Date(r.last_read),
         };
       }
     }
+    this.data = data;
   }
 
   getClient(): StreamChat<StreamChatGenerics> {
diff --git a/src/types.ts b/src/types.ts
index 8ad93215e6..f391fcd967 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -41,6 +41,8 @@ export type DefaultGenerics = {
   commandType: LiteralStringForUnion;
   eventType: UR;
   messageType: UR;
+  pollOptionType: UR;
+  pollType: UR;
   reactionType: UR;
   userType: UR;
 };
@@ -51,6 +53,8 @@ export type ExtendableGenerics = {
   commandType: string;
   eventType: UR;
   messageType: UR;
+  pollOptionType: UR;
+  pollType: UR;
   reactionType: UR;
   userType: UR;
 };
@@ -93,6 +97,7 @@ export type AppSettingsAPIResponse<StreamChatGenerics extends ExtendableGenerics
         message_retention?: string;
         mutes?: boolean;
         name?: string;
+        polls?: boolean;
         push_notifications?: boolean;
         quotes?: boolean;
         reactions?: boolean;
@@ -452,6 +457,8 @@ export type FormatMessageResponse<StreamChatGenerics extends ExtendableGenerics
     commandType: StreamChatGenerics['commandType'];
     eventType: StreamChatGenerics['eventType'];
     messageType: {};
+    pollOptionType: StreamChatGenerics['pollOptionType'];
+    pollType: StreamChatGenerics['pollType'];
     reactionType: StreamChatGenerics['reactionType'];
     userType: StreamChatGenerics['userType'];
   }>,
@@ -614,6 +621,7 @@ export type MessageResponse<
 export type MessageResponseBase<
   StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
 > = MessageBase<StreamChatGenerics> & {
+  poll: PollResponse<StreamChatGenerics>;
   type: MessageLabel;
   args?: string;
   before_message_send_failed?: boolean;
@@ -890,6 +898,7 @@ export type CreateChannelOptions<StreamChatGenerics extends ExtendableGenerics =
   mutes?: boolean;
   name?: string;
   permissions?: PermissionObject[];
+  polls?: boolean;
   push_notifications?: boolean;
   quotes?: boolean;
   reactions?: boolean;
@@ -1159,6 +1168,8 @@ export type Event<StreamChatGenerics extends ExtendableGenerics = DefaultGeneric
   mode?: string;
   online?: boolean;
   parent_id?: string;
+  poll?: PollResponse<StreamChatGenerics>;
+  poll_vote?: PollVote<StreamChatGenerics>;
   queriedChannels?: {
     channels: ChannelAPIResponse<StreamChatGenerics>[];
     isLatestMessageSet?: boolean;
@@ -1365,6 +1376,8 @@ export type ChannelFilters<StreamChatGenerics extends ExtendableGenerics = Defau
           commandType: StreamChatGenerics['commandType'];
           eventType: StreamChatGenerics['eventType'];
           messageType: StreamChatGenerics['messageType'];
+          pollOptionType: StreamChatGenerics['pollOptionType'];
+          pollType: StreamChatGenerics['pollType'];
           reactionType: StreamChatGenerics['reactionType'];
           userType: StreamChatGenerics['userType'];
         }>,
@@ -1378,6 +1391,8 @@ export type ChannelFilters<StreamChatGenerics extends ExtendableGenerics = Defau
                 commandType: StreamChatGenerics['commandType'];
                 eventType: StreamChatGenerics['eventType'];
                 messageType: StreamChatGenerics['messageType'];
+                pollOptionType: StreamChatGenerics['pollOptionType'];
+                pollType: StreamChatGenerics['pollType'];
                 reactionType: StreamChatGenerics['reactionType'];
                 userType: StreamChatGenerics['userType'];
               }>[Key]
@@ -1390,6 +1405,8 @@ export type ChannelFilters<StreamChatGenerics extends ExtendableGenerics = Defau
               commandType: StreamChatGenerics['commandType'];
               eventType: StreamChatGenerics['eventType'];
               messageType: StreamChatGenerics['messageType'];
+              pollOptionType: StreamChatGenerics['pollOptionType'];
+              pollType: StreamChatGenerics['pollType'];
               reactionType: StreamChatGenerics['reactionType'];
               userType: StreamChatGenerics['userType'];
             }>[Key]
@@ -1397,6 +1414,94 @@ export type ChannelFilters<StreamChatGenerics extends ExtendableGenerics = Defau
     }
 >;
 
+export type QueryPollsOptions = Pager;
+
+export type VotesFiltersOptions = {
+  is_answer?: boolean;
+  option_id?: string;
+  user_id?: string;
+};
+
+export type QueryVotesOptions = Pager;
+
+export type QueryPollsFilters = QueryFilters<
+  {
+    id?: RequireOnlyOne<Pick<QueryFilter<PollResponse['id']>, '$eq' | '$in'>> | PrimitiveFilter<PollResponse['id']>;
+  } & {
+    user_id?:
+      | RequireOnlyOne<Pick<QueryFilter<VotesFiltersOptions['user_id']>, '$eq' | '$in'>>
+      | PrimitiveFilter<VotesFiltersOptions['user_id']>;
+  } & {
+    is_closed?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['is_closed']>, '$eq'>>
+      | PrimitiveFilter<PollResponse['is_closed']>;
+  } & {
+    max_votes_allowed?:
+      | RequireOnlyOne<
+          Pick<QueryFilter<PollResponse['max_votes_allowed']>, '$eq' | '$ne' | '$gt' | '$lt' | '$gte' | '$lte'>
+        >
+      | PrimitiveFilter<PollResponse['max_votes_allowed']>;
+  } & {
+    allow_answers?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['allow_answers']>, '$eq'>>
+      | PrimitiveFilter<PollResponse['allow_answers']>;
+  } & {
+    allow_user_suggested_options?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['allow_user_suggested_options']>, '$eq'>>
+      | PrimitiveFilter<PollResponse['allow_user_suggested_options']>;
+  } & {
+    voting_visibility?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['voting_visibility']>, '$eq'>>
+      | PrimitiveFilter<PollResponse['voting_visibility']>;
+  } & {
+    created_at?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['created_at']>, '$eq' | '$gt' | '$lt' | '$gte' | '$lte'>>
+      | PrimitiveFilter<PollResponse['created_at']>;
+  } & {
+    created_by_id?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['created_by_id']>, '$eq' | '$in'>>
+      | PrimitiveFilter<PollResponse['created_by_id']>;
+  } & {
+    updated_at?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['updated_at']>, '$eq' | '$gt' | '$lt' | '$gte' | '$lte'>>
+      | PrimitiveFilter<PollResponse['updated_at']>;
+  } & {
+    name?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['name']>, '$eq' | '$in'>>
+      | PrimitiveFilter<PollResponse['name']>;
+  }
+>;
+
+export type QueryVotesFilters = QueryFilters<
+  {
+    id?: RequireOnlyOne<Pick<QueryFilter<PollResponse['id']>, '$eq' | '$in'>> | PrimitiveFilter<PollResponse['id']>;
+  } & {
+    option_id?:
+      | RequireOnlyOne<Pick<QueryFilter<VotesFiltersOptions['option_id']>, '$eq' | '$in'>>
+      | PrimitiveFilter<VotesFiltersOptions['option_id']>;
+  } & {
+    is_answer?:
+      | RequireOnlyOne<Pick<QueryFilter<VotesFiltersOptions['is_answer']>, '$eq'>>
+      | PrimitiveFilter<VotesFiltersOptions['is_answer']>;
+  } & {
+    user_id?:
+      | RequireOnlyOne<Pick<QueryFilter<VotesFiltersOptions['user_id']>, '$eq' | '$in'>>
+      | PrimitiveFilter<VotesFiltersOptions['user_id']>;
+  } & {
+    created_at?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['created_at']>, '$eq' | '$gt' | '$lt' | '$gte' | '$lte'>>
+      | PrimitiveFilter<PollResponse['created_at']>;
+  } & {
+    created_by_id?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['created_by_id']>, '$eq' | '$in'>>
+      | PrimitiveFilter<PollResponse['created_by_id']>;
+  } & {
+    updated_at?:
+      | RequireOnlyOne<Pick<QueryFilter<PollResponse['updated_at']>, '$eq' | '$gt' | '$lt' | '$gte' | '$lte'>>
+      | PrimitiveFilter<PollResponse['updated_at']>;
+  }
+>;
+
 export type ContainsOperator<CustomType = {}> = {
   [Key in keyof CustomType]?: CustomType[Key] extends (infer ContainType)[]
     ?
@@ -1429,6 +1534,8 @@ export type MessageFilters<StreamChatGenerics extends ExtendableGenerics = Defau
           commandType: StreamChatGenerics['commandType'];
           eventType: StreamChatGenerics['eventType'];
           messageType: {};
+          pollOptionType: StreamChatGenerics['pollOptionType'];
+          pollType: StreamChatGenerics['pollType'];
           reactionType: StreamChatGenerics['reactionType'];
           userType: StreamChatGenerics['userType'];
         }>,
@@ -1442,6 +1549,8 @@ export type MessageFilters<StreamChatGenerics extends ExtendableGenerics = Defau
                 commandType: StreamChatGenerics['commandType'];
                 eventType: StreamChatGenerics['eventType'];
                 messageType: {};
+                pollOptionType: StreamChatGenerics['pollOptionType'];
+                pollType: StreamChatGenerics['pollType'];
                 reactionType: StreamChatGenerics['reactionType'];
                 userType: StreamChatGenerics['userType'];
               }>[Key]
@@ -1454,6 +1563,8 @@ export type MessageFilters<StreamChatGenerics extends ExtendableGenerics = Defau
               commandType: StreamChatGenerics['commandType'];
               eventType: StreamChatGenerics['eventType'];
               messageType: {};
+              pollOptionType: StreamChatGenerics['pollOptionType'];
+              pollType: StreamChatGenerics['pollType'];
               reactionType: StreamChatGenerics['reactionType'];
               userType: StreamChatGenerics['userType'];
             }>[Key]
@@ -1532,6 +1643,8 @@ export type UserFilters<StreamChatGenerics extends ExtendableGenerics = DefaultG
           commandType: StreamChatGenerics['commandType'];
           eventType: StreamChatGenerics['eventType'];
           messageType: StreamChatGenerics['messageType'];
+          pollOptionType: StreamChatGenerics['pollOptionType'];
+          pollType: StreamChatGenerics['pollType'];
           reactionType: StreamChatGenerics['reactionType'];
           userType: {};
         }>,
@@ -1545,6 +1658,8 @@ export type UserFilters<StreamChatGenerics extends ExtendableGenerics = DefaultG
                 commandType: StreamChatGenerics['commandType'];
                 eventType: StreamChatGenerics['eventType'];
                 messageType: StreamChatGenerics['messageType'];
+                pollOptionType: StreamChatGenerics['pollOptionType'];
+                pollType: StreamChatGenerics['pollType'];
                 reactionType: StreamChatGenerics['reactionType'];
                 userType: {};
               }>[Key]
@@ -1557,6 +1672,8 @@ export type UserFilters<StreamChatGenerics extends ExtendableGenerics = DefaultG
               commandType: StreamChatGenerics['commandType'];
               eventType: StreamChatGenerics['eventType'];
               messageType: StreamChatGenerics['messageType'];
+              pollOptionType: StreamChatGenerics['pollOptionType'];
+              pollType: StreamChatGenerics['pollType'];
               reactionType: StreamChatGenerics['reactionType'];
               userType: {};
             }>[Key]
@@ -1631,6 +1748,26 @@ export type QuerySort<StreamChatGenerics extends ExtendableGenerics = DefaultGen
   | SearchMessageSort<StreamChatGenerics>
   | UserSort<StreamChatGenerics>;
 
+export type PollSort = PollSortBase | Array<PollSortBase>;
+
+export type PollSortBase = {
+  created_at?: AscDesc;
+  id?: AscDesc;
+  is_closed?: AscDesc;
+  name?: AscDesc;
+  updated_at?: AscDesc;
+};
+
+export type VoteSort = VoteSortBase | Array<VoteSortBase>;
+
+export type VoteSortBase = {
+  created_at?: AscDesc;
+  id?: AscDesc;
+  is_closed?: AscDesc;
+  name?: AscDesc;
+  updated_at?: AscDesc;
+};
+
 /**
  * Base Types
  */
@@ -1820,6 +1957,7 @@ export type ChannelConfigFields = {
   message_retention?: string;
   mutes?: boolean;
   name?: string;
+  polls?: boolean;
   push_notifications?: boolean;
   quotes?: boolean;
   reactions?: boolean;
@@ -2103,7 +2241,8 @@ export type EndpointName =
   | 'ListImports'
   | 'UpsertPushProvider'
   | 'DeletePushProvider'
-  | 'ListPushProviders';
+  | 'ListPushProviders'
+  | 'CreatePoll';
 
 export type ExportChannelRequest = {
   id: string;
@@ -2203,6 +2342,7 @@ export type MessageBase<
   pin_expires?: string | null;
   pinned?: boolean;
   pinned_at?: string | null;
+  poll_id?: string;
   quoted_message_id?: string;
   show_in_channel?: boolean;
   silent?: boolean;
@@ -2479,8 +2619,8 @@ export type DeleteType = 'soft' | 'hard' | 'pruning';
   DeleteUserOptions specifies a collection of one or more `user_ids` to be deleted.
 
   `user`:
-    - soft: marks user as deleted and retains all user data 
-    - pruning: marks user as deleted and nullifies user information 
+    - soft: marks user as deleted and retains all user data
+    - pruning: marks user as deleted and nullifies user information
     - hard: deletes user completely - this requires hard option for messages and conversation as well
   `conversations`:
     - soft: marks all conversation channels as deleted (same effect as Delete Channels with 'hard' option disabled)
@@ -2743,3 +2883,152 @@ export class ErrorFromResponse<T> extends Error {
   response?: AxiosResponse<T>;
   status?: number;
 }
+
+export type QueryPollsResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  polls: PollResponse<StreamChatGenerics>[];
+  next?: string;
+};
+
+export type CreatePollAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  poll: PollResponse<StreamChatGenerics>;
+};
+
+export type GetPollAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  poll: PollResponse<StreamChatGenerics>;
+};
+
+export type UpdatePollAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  poll: PollResponse<StreamChatGenerics>;
+};
+
+export type PollResponse<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = StreamChatGenerics['pollType'] & {
+  answers_count: number;
+  created_at: string;
+  created_by: UserResponse<StreamChatGenerics> | null;
+  created_by_id: string;
+  enforce_unique_vote: boolean;
+  id: string;
+  latest_answers: PollVote<StreamChatGenerics>[];
+  latest_votes_by_option: Record<string, PollVote<StreamChatGenerics>[]>;
+  max_votes_allowed: number;
+  name: string;
+  options: PollOption<StreamChatGenerics>[];
+  updated_at: string;
+  vote_count: number;
+  vote_counts_by_option: Record<string, number>;
+  allow_answers?: boolean;
+  allow_user_suggested_options?: boolean;
+  channel?: ChannelAPIResponse<StreamChatGenerics> | null;
+  cid?: string;
+  description?: string;
+  is_closed?: boolean;
+  own_votes?: PollVote<StreamChatGenerics>[];
+  voting_visibility?: VotingVisibility;
+};
+
+export type PollOption<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  created_at: string;
+  id: string;
+  poll_id: string;
+  text: string;
+  updated_at: string;
+  vote_count: number;
+  votes?: PollVote<StreamChatGenerics>[];
+};
+
+export enum VotingVisibility {
+  anonymous = 'anonymous',
+  public = 'public',
+}
+
+export type PollData<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = StreamChatGenerics['pollType'] & {
+  name: string;
+  allow_answers?: boolean;
+  allow_user_suggested_options?: boolean;
+  description?: string;
+  enforce_unique_vote?: boolean;
+  id?: string;
+  is_closed?: boolean;
+  max_votes_allowed?: number;
+  options?: PollOptionData<StreamChatGenerics>[];
+  user_id?: string;
+  voting_visibility?: VotingVisibility;
+};
+
+export type PartialPollUpdate<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  // id: string;
+  set?: Partial<PollResponse<StreamChatGenerics>>;
+  unset?: Array<keyof PollResponse<StreamChatGenerics>>;
+};
+
+export type PollOptionData<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = StreamChatGenerics['pollType'] & {
+  text: string;
+  id?: string;
+  position?: number;
+};
+
+export type PartialPollOptionUpdate<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  set?: Partial<PollOptionResponse<StreamChatGenerics>>;
+  unset?: Array<keyof PollOptionResponse<StreamChatGenerics>>;
+};
+
+export type PollVoteData = {
+  answer_text?: string;
+  is_answer?: boolean;
+  option_id?: string;
+};
+
+export type PollPaginationOptions = {
+  limit?: number;
+  next?: string;
+};
+
+export type CreatePollOptionAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  poll_option: PollOptionResponse<StreamChatGenerics>;
+};
+
+export type GetPollOptionAPIResponse<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = CreatePollOptionAPIResponse<StreamChatGenerics>;
+export type UpdatePollOptionAPIResponse<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = CreatePollOptionAPIResponse<StreamChatGenerics>;
+
+export type PollOptionResponse<
+  StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
+> = StreamChatGenerics['pollType'] & {
+  created_at: string;
+  id: string;
+  poll_id: string;
+  position: number;
+  text: string;
+  updated_at: string;
+  vote_count: number;
+  votes?: PollVote<StreamChatGenerics>[];
+};
+
+export type PollVote<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  created_at: string;
+  id: string;
+  is_answer: boolean;
+  poll_id: string;
+  user_id: string;
+  answer_text?: string;
+  option_id?: string;
+  user?: UserResponse<StreamChatGenerics>;
+};
+
+export type PollVotesAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  votes: PollVote<StreamChatGenerics>[];
+  next?: string;
+};
+
+export type CastVoteAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  vote: PollVote<StreamChatGenerics>;
+};