twitter-openapi-python-generated 0.0.34__py3-none-any.whl → 0.0.35__py3-none-any.whl

twitter_openapi_python_generated/api/tweet_api.py

@@ -19,8 +19,12 @@ from typing_extensions import Annotated
 from pydantic import StrictStr
 from twitter_openapi_python_generated.models.bookmarks_response import BookmarksResponse
 from twitter_openapi_python_generated.models.community_about_timeline_response import CommunityAboutTimelineResponse
+from twitter_openapi_python_generated.models.community_discovery_timeline_response import CommunityDiscoveryTimelineResponse
 from twitter_openapi_python_generated.models.community_media_timeline_response import CommunityMediaTimelineResponse
 from twitter_openapi_python_generated.models.community_tweets_timeline_response import CommunityTweetsTimelineResponse
+from twitter_openapi_python_generated.models.connect_tab_timeline_response import ConnectTabTimelineResponse
+from twitter_openapi_python_generated.models.explore_page_response import ExplorePageResponse
+from twitter_openapi_python_generated.models.generic_timeline_by_id_response import GenericTimelineByIdResponse
 from twitter_openapi_python_generated.models.list_latest_tweets_timeline_response import ListLatestTweetsTimelineResponse
 from twitter_openapi_python_generated.models.notifications_timeline_response import NotificationsTimelineResponse
 from twitter_openapi_python_generated.models.search_timeline_response import SearchTimelineResponse
@@ -681,6 +685,323 @@ class TweetApi:
 
 
 
+    @validate_call
+    def get_community_discovery_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> CommunityDiscoveryTimelineResponse:
+        """get_community_discovery_timeline
+
+        get the communities discovery timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_discovery_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityDiscoveryTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_community_discovery_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CommunityDiscoveryTimelineResponse]:
+        """get_community_discovery_timeline
+
+        get the communities discovery timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_discovery_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityDiscoveryTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_community_discovery_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_community_discovery_timeline
+
+        get the communities discovery timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_discovery_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityDiscoveryTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_community_discovery_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/CommunityDiscoveryTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def get_community_media_timeline(
         self,
@@ -699,10 +1020,2597 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CommunityMediaTimelineResponse:
-        """get_community_media_timeline
+    ) -> CommunityMediaTimelineResponse:
+        """get_community_media_timeline
+
+        get media list of community
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_media_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityMediaTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_community_media_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CommunityMediaTimelineResponse]:
+        """get_community_media_timeline
+
+        get media list of community
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_media_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityMediaTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_community_media_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_community_media_timeline
+
+        get media list of community
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_media_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityMediaTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_community_media_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/CommunityMediaTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_community_tweets_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> CommunityTweetsTimelineResponse:
+        """get_community_tweets_timeline
+
+        get tweet list of community. rankingMode:[Recency, Relevance]
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_tweets_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityTweetsTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_community_tweets_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[CommunityTweetsTimelineResponse]:
+        """get_community_tweets_timeline
+
+        get tweet list of community. rankingMode:[Recency, Relevance]
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_tweets_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityTweetsTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_community_tweets_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_community_tweets_timeline
+
+        get tweet list of community. rankingMode:[Recency, Relevance]
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_community_tweets_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "CommunityTweetsTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_community_tweets_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/CommunityTweetsTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_connect_tab_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ConnectTabTimelineResponse:
+        """get_connect_tab_timeline
+
+        get the Connect tab (who to follow) timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_connect_tab_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConnectTabTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_connect_tab_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[ConnectTabTimelineResponse]:
+        """get_connect_tab_timeline
+
+        get the Connect tab (who to follow) timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_connect_tab_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConnectTabTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_connect_tab_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_connect_tab_timeline
+
+        get the Connect tab (who to follow) timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_connect_tab_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ConnectTabTimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_connect_tab_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/ConnectTabTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_explore_page(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ExplorePageResponse:
+        """get_explore_page
+
+        get the explore page (segmented timelines)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_explore_page_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExplorePageResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_explore_page_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[ExplorePageResponse]:
+        """get_explore_page
+
+        get the explore page (segmented timelines)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_explore_page_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExplorePageResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_explore_page_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_explore_page
+
+        get the explore page (segmented timelines)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_explore_page_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "ExplorePageResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_explore_page_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/ExplorePage',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_generic_timeline_by_id(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> GenericTimelineByIdResponse:
+        """get_generic_timeline_by_id
+
+        get a generic timeline by its id (explore tabs)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_generic_timeline_by_id_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GenericTimelineByIdResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_generic_timeline_by_id_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[GenericTimelineByIdResponse]:
+        """get_generic_timeline_by_id
+
+        get a generic timeline by its id (explore tabs)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_generic_timeline_by_id_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GenericTimelineByIdResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_generic_timeline_by_id_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_generic_timeline_by_id
+
+        get a generic timeline by its id (explore tabs)
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_generic_timeline_by_id_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "GenericTimelineByIdResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_generic_timeline_by_id_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/GenericTimelineById',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_home_latest_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> TimelineResponse:
+        """get_home_latest_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_latest_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_home_latest_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[TimelineResponse]:
+        """get_home_latest_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_latest_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_home_latest_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_home_latest_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_latest_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_home_latest_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        field_toggles,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/HomeLatestTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_home_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> TimelineResponse:
+        """get_home_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_home_timeline_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[TimelineResponse]:
+        """get_home_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_home_timeline_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_home_timeline
+
+        get tweet list of timeline
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_home_timeline_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TimelineResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_home_timeline_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        field_toggles,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/HomeTimeline',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_likes(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> UserTweetsResponse:
+        """get_likes
+
+        get user likes tweets
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_likes_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UserTweetsResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_likes_with_http_info(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_likes
+
+        get user likes tweets
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_likes_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UserTweetsResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_likes_without_preload_content(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        field_toggles: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """get_likes
+
+        get user likes tweets
+
+        :param path_query_id: (required)
+        :type path_query_id: str
+        :param variables: (required)
+        :type variables: str
+        :param features: (required)
+        :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_likes_serialize(
+            path_query_id=path_query_id,
+            variables=variables,
+            features=features,
+            field_toggles=field_toggles,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "UserTweetsResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_likes_serialize(
+        self,
+        path_query_id,
+        variables,
+        features,
+        field_toggles,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if path_query_id is not None:
+            _path_params['pathQueryId'] = path_query_id
+        # process the query parameters
+        if variables is not None:
+            
+            _query_params.append(('variables', variables))
+            
+        if features is not None:
+            
+            _query_params.append(('features', features))
+            
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'Accept', 
+            'ClientLanguage', 
+            'Priority', 
+            'Referer', 
+            'SecFetchDest', 
+            'SecChUaPlatform', 
+            'SecFetchMode', 
+            'CsrfToken', 
+            'ClientUuid', 
+            'BearerAuth', 
+            'GuestToken', 
+            'SecChUa', 
+            'CookieGt0', 
+            'ClientTransactionId', 
+            'ActiveUser', 
+            'CookieCt0', 
+            'UserAgent', 
+            'AcceptLanguage', 
+            'SecFetchSite', 
+            'AuthType', 
+            'CookieAuthToken', 
+            'SecChUaMobile', 
+            'AcceptEncoding'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/graphql/{pathQueryId}/Likes',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def get_list_latest_tweets_timeline(
+        self,
+        path_query_id: StrictStr,
+        variables: StrictStr,
+        features: StrictStr,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ListLatestTweetsTimelineResponse:
+        """get_list_latest_tweets_timeline
 
-        get media list of community
+        get tweet list of timeline
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -732,7 +3640,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_media_timeline_serialize(
+        _param = self._get_list_latest_tweets_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -743,7 +3651,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityMediaTimelineResponse",
+            '200': "ListLatestTweetsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -757,7 +3665,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_community_media_timeline_with_http_info(
+    def get_list_latest_tweets_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -774,10 +3682,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CommunityMediaTimelineResponse]:
-        """get_community_media_timeline
+    ) -> ApiResponse[ListLatestTweetsTimelineResponse]:
+        """get_list_latest_tweets_timeline
 
-        get media list of community
+        get tweet list of timeline
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -807,7 +3715,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_media_timeline_serialize(
+        _param = self._get_list_latest_tweets_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -818,7 +3726,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityMediaTimelineResponse",
+            '200': "ListLatestTweetsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -832,7 +3740,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_community_media_timeline_without_preload_content(
+    def get_list_latest_tweets_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -850,9 +3758,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_community_media_timeline
+        """get_list_latest_tweets_timeline
 
-        get media list of community
+        get tweet list of timeline
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -882,7 +3790,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_media_timeline_serialize(
+        _param = self._get_list_latest_tweets_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -893,7 +3801,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityMediaTimelineResponse",
+            '200': "ListLatestTweetsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -902,7 +3810,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_community_media_timeline_serialize(
+    def _get_list_latest_tweets_timeline_serialize(
         self,
         path_query_id,
         variables,
@@ -982,7 +3890,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/CommunityMediaTimeline',
+            resource_path='/graphql/{pathQueryId}/ListLatestTweetsTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -999,7 +3907,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_community_tweets_timeline(
+    def get_notifications_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1016,10 +3924,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> CommunityTweetsTimelineResponse:
-        """get_community_tweets_timeline
+    ) -> NotificationsTimelineResponse:
+        """get_notifications_timeline
 
-        get tweet list of community. rankingMode:[Recency, Relevance]
+        get notification list. timeline_type:[All, Verified, Mentions]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1049,7 +3957,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_tweets_timeline_serialize(
+        _param = self._get_notifications_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1060,7 +3968,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityTweetsTimelineResponse",
+            '200': "NotificationsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1074,7 +3982,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_community_tweets_timeline_with_http_info(
+    def get_notifications_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1091,10 +3999,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[CommunityTweetsTimelineResponse]:
-        """get_community_tweets_timeline
+    ) -> ApiResponse[NotificationsTimelineResponse]:
+        """get_notifications_timeline
 
-        get tweet list of community. rankingMode:[Recency, Relevance]
+        get notification list. timeline_type:[All, Verified, Mentions]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1124,7 +4032,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_tweets_timeline_serialize(
+        _param = self._get_notifications_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1135,7 +4043,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityTweetsTimelineResponse",
+            '200': "NotificationsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1149,7 +4057,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_community_tweets_timeline_without_preload_content(
+    def get_notifications_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1167,9 +4075,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_community_tweets_timeline
+        """get_notifications_timeline
 
-        get tweet list of community. rankingMode:[Recency, Relevance]
+        get notification list. timeline_type:[All, Verified, Mentions]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1199,7 +4107,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_community_tweets_timeline_serialize(
+        _param = self._get_notifications_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1210,7 +4118,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "CommunityTweetsTimelineResponse",
+            '200': "NotificationsTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1219,7 +4127,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_community_tweets_timeline_serialize(
+    def _get_notifications_timeline_serialize(
         self,
         path_query_id,
         variables,
@@ -1299,7 +4207,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/CommunityTweetsTimeline',
+            resource_path='/graphql/{pathQueryId}/NotificationsTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1316,7 +4224,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_latest_timeline(
+    def get_search_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1333,10 +4241,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TimelineResponse:
-        """get_home_latest_timeline
+    ) -> SearchTimelineResponse:
+        """get_search_timeline
 
-        get tweet list of timeline
+        search tweet list. product:[Top, Latest, People, Photos, Videos]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1366,7 +4274,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_latest_timeline_serialize(
+        _param = self._get_search_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1377,7 +4285,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "SearchTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1391,7 +4299,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_latest_timeline_with_http_info(
+    def get_search_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1408,10 +4316,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TimelineResponse]:
-        """get_home_latest_timeline
+    ) -> ApiResponse[SearchTimelineResponse]:
+        """get_search_timeline
 
-        get tweet list of timeline
+        search tweet list. product:[Top, Latest, People, Photos, Videos]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1441,7 +4349,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_latest_timeline_serialize(
+        _param = self._get_search_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1452,7 +4360,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "SearchTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1466,7 +4374,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_latest_timeline_without_preload_content(
+    def get_search_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1484,9 +4392,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_home_latest_timeline
+        """get_search_timeline
 
-        get tweet list of timeline
+        search tweet list. product:[Top, Latest, People, Photos, Videos]
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1516,7 +4424,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_latest_timeline_serialize(
+        _param = self._get_search_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -1527,7 +4435,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "SearchTimelineResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1536,7 +4444,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_home_latest_timeline_serialize(
+    def _get_search_timeline_serialize(
         self,
         path_query_id,
         variables,
@@ -1616,7 +4524,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/HomeLatestTimeline',
+            resource_path='/graphql/{pathQueryId}/SearchTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1633,11 +4541,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_timeline(
+    def get_tweet_detail(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1650,10 +4559,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TimelineResponse:
-        """get_home_timeline
+    ) -> TweetDetailResponse:
+        """get_tweet_detail
 
-        get tweet list of timeline
+        get TweetDetail
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1661,6 +4570,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1683,10 +4594,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_timeline_serialize(
+        _param = self._get_tweet_detail_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1694,7 +4606,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "TweetDetailResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1708,11 +4620,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_timeline_with_http_info(
+    def get_tweet_detail_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1725,10 +4638,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TimelineResponse]:
-        """get_home_timeline
+    ) -> ApiResponse[TweetDetailResponse]:
+        """get_tweet_detail
 
-        get tweet list of timeline
+        get TweetDetail
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1736,6 +4649,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1758,10 +4673,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_timeline_serialize(
+        _param = self._get_tweet_detail_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1769,7 +4685,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "TweetDetailResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1783,11 +4699,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_home_timeline_without_preload_content(
+    def get_tweet_detail_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1801,9 +4718,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_home_timeline
+        """get_tweet_detail
 
-        get tweet list of timeline
+        get TweetDetail
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -1811,6 +4728,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -1833,10 +4752,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_home_timeline_serialize(
+        _param = self._get_tweet_detail_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1844,7 +4764,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TimelineResponse",
+            '200': "TweetDetailResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1853,11 +4773,12 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_home_timeline_serialize(
+    def _get_tweet_detail_serialize(
         self,
         path_query_id,
         variables,
         features,
+        field_toggles,
         _request_auth,
         _content_type,
         _headers,
@@ -1890,6 +4811,10 @@ class TweetApi:
             
             _query_params.append(('features', features))
             
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -1933,7 +4858,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/HomeTimeline',
+            resource_path='/graphql/{pathQueryId}/TweetDetail',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1950,7 +4875,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_likes(
+    def get_user_highlights_tweets(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -1968,10 +4893,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UserTweetsResponse:
-        """get_likes
+    ) -> UserHighlightsTweetsResponse:
+        """get_user_highlights_tweets
 
-        get user likes tweets
+        get user highlights tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2003,7 +4928,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_likes_serialize(
+        _param = self._get_user_highlights_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -2015,7 +4940,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserTweetsResponse",
+            '200': "UserHighlightsTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2029,7 +4954,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_likes_with_http_info(
+    def get_user_highlights_tweets_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -2047,10 +4972,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UserTweetsResponse]:
-        """get_likes
+    ) -> ApiResponse[UserHighlightsTweetsResponse]:
+        """get_user_highlights_tweets
 
-        get user likes tweets
+        get user highlights tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2082,7 +5007,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_likes_serialize(
+        _param = self._get_user_highlights_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -2094,7 +5019,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserTweetsResponse",
+            '200': "UserHighlightsTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2108,7 +5033,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_likes_without_preload_content(
+    def get_user_highlights_tweets_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -2127,9 +5052,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_likes
+        """get_user_highlights_tweets
 
-        get user likes tweets
+        get user highlights tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2161,7 +5086,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_likes_serialize(
+        _param = self._get_user_highlights_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -2173,7 +5098,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserTweetsResponse",
+            '200': "UserHighlightsTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2182,7 +5107,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_likes_serialize(
+    def _get_user_highlights_tweets_serialize(
         self,
         path_query_id,
         variables,
@@ -2267,7 +5192,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/Likes',
+            resource_path='/graphql/{pathQueryId}/UserHighlightsTweets',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2284,11 +5209,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_list_latest_tweets_timeline(
+    def get_user_media(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2301,10 +5227,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ListLatestTweetsTimelineResponse:
-        """get_list_latest_tweets_timeline
+    ) -> UserTweetsResponse:
+        """get_user_media
 
-        get tweet list of timeline
+        get user media tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2312,6 +5238,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2334,10 +5262,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_list_latest_tweets_timeline_serialize(
+        _param = self._get_user_media_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2345,7 +5274,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ListLatestTweetsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2359,11 +5288,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_list_latest_tweets_timeline_with_http_info(
+    def get_user_media_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2376,10 +5306,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[ListLatestTweetsTimelineResponse]:
-        """get_list_latest_tweets_timeline
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_user_media
 
-        get tweet list of timeline
+        get user media tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2387,6 +5317,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2409,10 +5341,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_list_latest_tweets_timeline_serialize(
+        _param = self._get_user_media_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2420,7 +5353,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ListLatestTweetsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2434,11 +5367,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_list_latest_tweets_timeline_without_preload_content(
+    def get_user_media_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2452,9 +5386,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_list_latest_tweets_timeline
+        """get_user_media
 
-        get tweet list of timeline
+        get user media tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2462,6 +5396,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2484,10 +5420,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_list_latest_tweets_timeline_serialize(
+        _param = self._get_user_media_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2495,7 +5432,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "ListLatestTweetsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2504,11 +5441,12 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_list_latest_tweets_timeline_serialize(
+    def _get_user_media_serialize(
         self,
         path_query_id,
         variables,
         features,
+        field_toggles,
         _request_auth,
         _content_type,
         _headers,
@@ -2541,6 +5479,10 @@ class TweetApi:
             
             _query_params.append(('features', features))
             
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -2584,7 +5526,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/ListLatestTweetsTimeline',
+            resource_path='/graphql/{pathQueryId}/UserMedia',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2601,11 +5543,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_notifications_timeline(
+    def get_user_originals_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2618,10 +5561,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> NotificationsTimelineResponse:
-        """get_notifications_timeline
+    ) -> UserTweetsResponse:
+        """get_user_originals_timeline
 
-        get notification list. timeline_type:[All, Verified, Mentions]
+        get user tweets (profile posts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2629,6 +5572,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2651,10 +5596,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_notifications_timeline_serialize(
+        _param = self._get_user_originals_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2662,7 +5608,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "NotificationsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2676,11 +5622,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_notifications_timeline_with_http_info(
+    def get_user_originals_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2693,10 +5640,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[NotificationsTimelineResponse]:
-        """get_notifications_timeline
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_user_originals_timeline
 
-        get notification list. timeline_type:[All, Verified, Mentions]
+        get user tweets (profile posts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2704,6 +5651,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2726,10 +5675,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_notifications_timeline_serialize(
+        _param = self._get_user_originals_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2737,7 +5687,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "NotificationsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2751,11 +5701,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_notifications_timeline_without_preload_content(
+    def get_user_originals_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2769,9 +5720,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_notifications_timeline
+        """get_user_originals_timeline
 
-        get notification list. timeline_type:[All, Verified, Mentions]
+        get user tweets (profile posts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2779,6 +5730,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2801,10 +5754,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_notifications_timeline_serialize(
+        _param = self._get_user_originals_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2812,7 +5766,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "NotificationsTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2821,11 +5775,12 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_notifications_timeline_serialize(
+    def _get_user_originals_timeline_serialize(
         self,
         path_query_id,
         variables,
         features,
+        field_toggles,
         _request_auth,
         _content_type,
         _headers,
@@ -2858,6 +5813,10 @@ class TweetApi:
             
             _query_params.append(('features', features))
             
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -2901,7 +5860,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/NotificationsTimeline',
+            resource_path='/graphql/{pathQueryId}/UserOriginalsTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -2918,11 +5877,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_search_timeline(
+    def get_user_replies_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -2935,10 +5895,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> SearchTimelineResponse:
-        """get_search_timeline
+    ) -> UserTweetsResponse:
+        """get_user_replies_timeline
 
-        search tweet list. product:[Top, Latest, People, Photos, Videos]
+        get user tweets and replies (profile replies tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -2946,6 +5906,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -2968,10 +5930,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_search_timeline_serialize(
+        _param = self._get_user_replies_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -2979,7 +5942,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SearchTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -2993,11 +5956,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_search_timeline_with_http_info(
+    def get_user_replies_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3010,10 +5974,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[SearchTimelineResponse]:
-        """get_search_timeline
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_user_replies_timeline
 
-        search tweet list. product:[Top, Latest, People, Photos, Videos]
+        get user tweets and replies (profile replies tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3021,6 +5985,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3043,10 +6009,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_search_timeline_serialize(
+        _param = self._get_user_replies_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3054,7 +6021,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SearchTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3068,11 +6035,12 @@ class TweetApi:
 
 
     @validate_call
-    def get_search_timeline_without_preload_content(
+    def get_user_replies_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
         features: StrictStr,
+        field_toggles: StrictStr,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -3086,9 +6054,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_search_timeline
+        """get_user_replies_timeline
 
-        search tweet list. product:[Top, Latest, People, Photos, Videos]
+        get user tweets and replies (profile replies tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3096,6 +6064,8 @@ class TweetApi:
         :type variables: str
         :param features: (required)
         :type features: str
+        :param field_toggles: (required)
+        :type field_toggles: str
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
                                  timeout. It can also be a pair (tuple) of
@@ -3118,10 +6088,11 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_search_timeline_serialize(
+        _param = self._get_user_replies_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
+            field_toggles=field_toggles,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -3129,7 +6100,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "SearchTimelineResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3138,11 +6109,12 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_search_timeline_serialize(
+    def _get_user_replies_timeline_serialize(
         self,
         path_query_id,
         variables,
         features,
+        field_toggles,
         _request_auth,
         _content_type,
         _headers,
@@ -3175,6 +6147,10 @@ class TweetApi:
             
             _query_params.append(('features', features))
             
+        if field_toggles is not None:
+            
+            _query_params.append(('fieldToggles', field_toggles))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
@@ -3218,7 +6194,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/SearchTimeline',
+            resource_path='/graphql/{pathQueryId}/UserRepliesTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3235,7 +6211,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_tweet_detail(
+    def get_user_reposts_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3253,10 +6229,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> TweetDetailResponse:
-        """get_tweet_detail
+    ) -> UserTweetsResponse:
+        """get_user_reposts_timeline
 
-        get TweetDetail
+        get user reposts (profile reposts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3288,7 +6264,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_tweet_detail_serialize(
+        _param = self._get_user_reposts_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3300,7 +6276,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TweetDetailResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3314,7 +6290,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_tweet_detail_with_http_info(
+    def get_user_reposts_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3332,10 +6308,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[TweetDetailResponse]:
-        """get_tweet_detail
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_user_reposts_timeline
 
-        get TweetDetail
+        get user reposts (profile reposts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3367,7 +6343,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_tweet_detail_serialize(
+        _param = self._get_user_reposts_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3379,7 +6355,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TweetDetailResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3393,7 +6369,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_tweet_detail_without_preload_content(
+    def get_user_reposts_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3412,9 +6388,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_tweet_detail
+        """get_user_reposts_timeline
 
-        get TweetDetail
+        get user reposts (profile reposts tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3446,7 +6422,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_tweet_detail_serialize(
+        _param = self._get_user_reposts_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3458,7 +6434,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "TweetDetailResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3467,7 +6443,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_tweet_detail_serialize(
+    def _get_user_reposts_timeline_serialize(
         self,
         path_query_id,
         variables,
@@ -3552,7 +6528,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/TweetDetail',
+            resource_path='/graphql/{pathQueryId}/UserRepostsTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3569,7 +6545,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_highlights_tweets(
+    def get_user_super_follow_tweets(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3587,10 +6563,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> UserHighlightsTweetsResponse:
-        """get_user_highlights_tweets
+    ) -> UserTweetsResponse:
+        """get_user_super_follow_tweets
 
-        get user highlights tweets
+        get user super follow tweets (subscriptions tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3622,7 +6598,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_highlights_tweets_serialize(
+        _param = self._get_user_super_follow_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3634,7 +6610,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserHighlightsTweetsResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3648,7 +6624,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_highlights_tweets_with_http_info(
+    def get_user_super_follow_tweets_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3666,10 +6642,10 @@ class TweetApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[UserHighlightsTweetsResponse]:
-        """get_user_highlights_tweets
+    ) -> ApiResponse[UserTweetsResponse]:
+        """get_user_super_follow_tweets
 
-        get user highlights tweets
+        get user super follow tweets (subscriptions tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3701,7 +6677,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_highlights_tweets_serialize(
+        _param = self._get_user_super_follow_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3713,7 +6689,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserHighlightsTweetsResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3727,7 +6703,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_highlights_tweets_without_preload_content(
+    def get_user_super_follow_tweets_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3746,9 +6722,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_user_highlights_tweets
+        """get_user_super_follow_tweets
 
-        get user highlights tweets
+        get user super follow tweets (subscriptions tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3780,7 +6756,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_highlights_tweets_serialize(
+        _param = self._get_user_super_follow_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3792,7 +6768,7 @@ class TweetApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "UserHighlightsTweetsResponse",
+            '200': "UserTweetsResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -3801,7 +6777,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_user_highlights_tweets_serialize(
+    def _get_user_super_follow_tweets_serialize(
         self,
         path_query_id,
         variables,
@@ -3886,7 +6862,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/UserHighlightsTweets',
+            resource_path='/graphql/{pathQueryId}/UserSuperFollowTweets',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -3903,7 +6879,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_media(
+    def get_user_tweets(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -3922,9 +6898,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UserTweetsResponse:
-        """get_user_media
+        """get_user_tweets
 
-        get user media tweets
+        get user tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -3956,7 +6932,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_media_serialize(
+        _param = self._get_user_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -3982,7 +6958,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_media_with_http_info(
+    def get_user_tweets_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4001,9 +6977,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UserTweetsResponse]:
-        """get_user_media
+        """get_user_tweets
 
-        get user media tweets
+        get user tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4035,7 +7011,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_media_serialize(
+        _param = self._get_user_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4061,7 +7037,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_media_without_preload_content(
+    def get_user_tweets_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4080,9 +7056,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_user_media
+        """get_user_tweets
 
-        get user media tweets
+        get user tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4114,7 +7090,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_media_serialize(
+        _param = self._get_user_tweets_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4135,7 +7111,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_user_media_serialize(
+    def _get_user_tweets_serialize(
         self,
         path_query_id,
         variables,
@@ -4220,7 +7196,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/UserMedia',
+            resource_path='/graphql/{pathQueryId}/UserTweets',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4237,7 +7213,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets(
+    def get_user_tweets_and_replies(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4256,9 +7232,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UserTweetsResponse:
-        """get_user_tweets
+        """get_user_tweets_and_replies
 
-        get user tweets
+        get user replies tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4290,7 +7266,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_serialize(
+        _param = self._get_user_tweets_and_replies_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4316,7 +7292,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets_with_http_info(
+    def get_user_tweets_and_replies_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4335,9 +7311,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UserTweetsResponse]:
-        """get_user_tweets
+        """get_user_tweets_and_replies
 
-        get user tweets
+        get user replies tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4369,7 +7345,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_serialize(
+        _param = self._get_user_tweets_and_replies_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4395,7 +7371,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets_without_preload_content(
+    def get_user_tweets_and_replies_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4414,9 +7390,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_user_tweets
+        """get_user_tweets_and_replies
 
-        get user tweets
+        get user replies tweets
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4448,7 +7424,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_serialize(
+        _param = self._get_user_tweets_and_replies_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4469,7 +7445,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_user_tweets_serialize(
+    def _get_user_tweets_and_replies_serialize(
         self,
         path_query_id,
         variables,
@@ -4554,7 +7530,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/UserTweets',
+            resource_path='/graphql/{pathQueryId}/UserTweetsAndReplies',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -4571,7 +7547,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets_and_replies(
+    def get_user_video_timeline(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4590,9 +7566,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> UserTweetsResponse:
-        """get_user_tweets_and_replies
+        """get_user_video_timeline
 
-        get user replies tweets
+        get user media (profile media tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4624,7 +7600,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_and_replies_serialize(
+        _param = self._get_user_video_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4650,7 +7626,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets_and_replies_with_http_info(
+    def get_user_video_timeline_with_http_info(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4669,9 +7645,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[UserTweetsResponse]:
-        """get_user_tweets_and_replies
+        """get_user_video_timeline
 
-        get user replies tweets
+        get user media (profile media tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4703,7 +7679,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_and_replies_serialize(
+        _param = self._get_user_video_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4729,7 +7705,7 @@ class TweetApi:
 
 
     @validate_call
-    def get_user_tweets_and_replies_without_preload_content(
+    def get_user_video_timeline_without_preload_content(
         self,
         path_query_id: StrictStr,
         variables: StrictStr,
@@ -4748,9 +7724,9 @@ class TweetApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """get_user_tweets_and_replies
+        """get_user_video_timeline
 
-        get user replies tweets
+        get user media (profile media tab)
 
         :param path_query_id: (required)
         :type path_query_id: str
@@ -4782,7 +7758,7 @@ class TweetApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._get_user_tweets_and_replies_serialize(
+        _param = self._get_user_video_timeline_serialize(
             path_query_id=path_query_id,
             variables=variables,
             features=features,
@@ -4803,7 +7779,7 @@ class TweetApi:
         return response_data.response
 
 
-    def _get_user_tweets_and_replies_serialize(
+    def _get_user_video_timeline_serialize(
         self,
         path_query_id,
         variables,
@@ -4888,7 +7864,7 @@ class TweetApi:
 
         return self.api_client.param_serialize(
             method='GET',
-            resource_path='/graphql/{pathQueryId}/UserTweetsAndReplies',
+            resource_path='/graphql/{pathQueryId}/UserVideoTimeline',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,