# coding: utf-8

"""
    YouTube Data API v3

    The YouTube Data API v3 is an API that provides access to YouTube data, such as videos, playlists, and channels.

    The version of the OpenAPI document: v3
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
from typing import Any, Dict, List, Optional, Tuple, Union
from typing_extensions import Annotated

from pydantic import Field, StrictBool, StrictStr, field_validator
from typing import List, Optional
from typing_extensions import Annotated
from youtube_ti.models.search_list_response import SearchListResponse

from youtube_ti.api_client import ApiClient, RequestSerialized
from youtube_ti.api_response import ApiResponse
from youtube_ti.rest import RESTResponseType


class SearchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def youtube_search_list(
        self,
        part: Annotated[List[StrictStr], Field(description="The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet.")],
        oauth_token: Annotated[Optional[StrictStr], Field(description="OAuth 2.0 token for the current user.")] = None,
        key: Annotated[Optional[StrictStr], Field(description="API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.")] = None,
        upload_type: Annotated[Optional[StrictStr], Field(description="Legacy upload protocol for media (e.g. \"media\", \"multipart\").")] = None,
        quota_user: Annotated[Optional[StrictStr], Field(description="Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.")] = None,
        upload_protocol: Annotated[Optional[StrictStr], Field(description="Upload protocol for media (e.g. \"raw\", \"multipart\").")] = None,
        param_callback: Annotated[Optional[StrictStr], Field(description="JSONP")] = None,
        fields: Annotated[Optional[StrictStr], Field(description="Selector specifying which fields to include in a partial response.")] = None,
        xgafv: Annotated[Optional[StrictStr], Field(description="V1 error format.")] = None,
        pretty_print: Annotated[Optional[StrictBool], Field(description="Returns response with indentations and line breaks.")] = None,
        access_token: Annotated[Optional[StrictStr], Field(description="OAuth access token.")] = None,
        alt: Annotated[Optional[StrictStr], Field(description="Data format for response.")] = None,
        channel_id: Annotated[Optional[StrictStr], Field(description="Filter on resources belonging to this channelId.")] = None,
        channel_type: Annotated[Optional[StrictStr], Field(description="Add a filter on the channel search.")] = None,
        event_type: Annotated[Optional[StrictStr], Field(description="Filter on the livestream status of the videos.")] = None,
        for_content_owner: Annotated[Optional[StrictBool], Field(description="Search owned by a content owner.")] = None,
        for_developer: Annotated[Optional[StrictBool], Field(description="Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.")] = None,
        for_mine: Annotated[Optional[StrictBool], Field(description="Search for the private videos of the authenticated user.")] = None,
        location: Annotated[Optional[StrictStr], Field(description="Filter on location of the video")] = None,
        location_radius: Annotated[Optional[StrictStr], Field(description="Filter on distance from the location (specified above).")] = None,
        max_results: Annotated[Optional[Annotated[int, Field(le=50, strict=True, ge=0)]], Field(description="The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.")] = None,
        on_behalf_of_content_owner: Annotated[Optional[StrictStr], Field(description="*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.")] = None,
        order: Annotated[Optional[StrictStr], Field(description="Sort order of the results.")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.")] = None,
        published_after: Annotated[Optional[StrictStr], Field(description="Filter on resources published after this date.")] = None,
        published_before: Annotated[Optional[StrictStr], Field(description="Filter on resources published before this date.")] = None,
        q: Annotated[Optional[StrictStr], Field(description="Textual search terms to match.")] = None,
        region_code: Annotated[Optional[StrictStr], Field(description="Display the content as seen by viewers in this country.")] = None,
        relevance_language: Annotated[Optional[StrictStr], Field(description="Return results relevant to this language.")] = None,
        safe_search: Annotated[Optional[StrictStr], Field(description="Indicates whether the search results should include restricted content as well as standard content.")] = None,
        topic_id: Annotated[Optional[StrictStr], Field(description="Restrict results to a particular topic.")] = None,
        type: Annotated[Optional[List[StrictStr]], Field(description="Restrict results to a particular set of resource types from One Platform.")] = None,
        video_caption: Annotated[Optional[StrictStr], Field(description="Filter on the presence of captions on the videos.")] = None,
        video_category_id: Annotated[Optional[StrictStr], Field(description="Filter on videos in a specific category.")] = None,
        video_definition: Annotated[Optional[StrictStr], Field(description="Filter on the definition of the videos.")] = None,
        video_dimension: Annotated[Optional[StrictStr], Field(description="Filter on 3d videos.")] = None,
        video_duration: Annotated[Optional[StrictStr], Field(description="Filter on the duration of the videos.")] = None,
        video_embeddable: Annotated[Optional[StrictStr], Field(description="Filter on embeddable videos.")] = None,
        video_license: Annotated[Optional[StrictStr], Field(description="Filter on the license of the videos.")] = None,
        video_paid_product_placement: Optional[StrictStr] = None,
        video_syndicated: Annotated[Optional[StrictStr], Field(description="Filter on syndicated videos.")] = None,
        video_type: Annotated[Optional[StrictStr], Field(description="Filter on videos of a specific type.")] = None,
        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__: Optional[StrictStr] = None,
    ) -> SearchListResponse:
        """youtube_search_list

        Retrieves a list of search resources

        :param part: The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet. (required)
        :type part: List[str]
        :param oauth_token: OAuth 2.0 token for the current user.
        :type oauth_token: str
        :param key: API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
        :type key: str
        :param upload_type: Legacy upload protocol for media (e.g. \"media\", \"multipart\").
        :type upload_type: str
        :param quota_user: Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
        :type quota_user: str
        :param upload_protocol: Upload protocol for media (e.g. \"raw\", \"multipart\").
        :type upload_protocol: str
        :param param_callback: JSONP
        :type param_callback: str
        :param fields: Selector specifying which fields to include in a partial response.
        :type fields: str
        :param xgafv: V1 error format.
        :type xgafv: str
        :param pretty_print: Returns response with indentations and line breaks.
        :type pretty_print: bool
        :param access_token: OAuth access token.
        :type access_token: str
        :param alt: Data format for response.
        :type alt: str
        :param channel_id: Filter on resources belonging to this channelId.
        :type channel_id: str
        :param channel_type: Add a filter on the channel search.
        :type channel_type: str
        :param event_type: Filter on the livestream status of the videos.
        :type event_type: str
        :param for_content_owner: Search owned by a content owner.
        :type for_content_owner: bool
        :param for_developer: Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.
        :type for_developer: bool
        :param for_mine: Search for the private videos of the authenticated user.
        :type for_mine: bool
        :param location: Filter on location of the video
        :type location: str
        :param location_radius: Filter on distance from the location (specified above).
        :type location_radius: str
        :param max_results: The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.
        :type max_results: int
        :param on_behalf_of_content_owner: *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.
        :type on_behalf_of_content_owner: str
        :param order: Sort order of the results.
        :type order: str
        :param page_token: The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.
        :type page_token: str
        :param published_after: Filter on resources published after this date.
        :type published_after: str
        :param published_before: Filter on resources published before this date.
        :type published_before: str
        :param q: Textual search terms to match.
        :type q: str
        :param region_code: Display the content as seen by viewers in this country.
        :type region_code: str
        :param relevance_language: Return results relevant to this language.
        :type relevance_language: str
        :param safe_search: Indicates whether the search results should include restricted content as well as standard content.
        :type safe_search: str
        :param topic_id: Restrict results to a particular topic.
        :type topic_id: str
        :param type: Restrict results to a particular set of resource types from One Platform.
        :type type: List[str]
        :param video_caption: Filter on the presence of captions on the videos.
        :type video_caption: str
        :param video_category_id: Filter on videos in a specific category.
        :type video_category_id: str
        :param video_definition: Filter on the definition of the videos.
        :type video_definition: str
        :param video_dimension: Filter on 3d videos.
        :type video_dimension: str
        :param video_duration: Filter on the duration of the videos.
        :type video_duration: str
        :param video_embeddable: Filter on embeddable videos.
        :type video_embeddable: str
        :param video_license: Filter on the license of the videos.
        :type video_license: str
        :param video_paid_product_placement:
        :type video_paid_product_placement: str
        :param video_syndicated: Filter on syndicated videos.
        :type video_syndicated: str
        :param video_type: Filter on videos of a specific type.
        :type video_type: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._youtube_search_list_serialize(
            part=part,
            oauth_token=oauth_token,
            key=key,
            upload_type=upload_type,
            quota_user=quota_user,
            upload_protocol=upload_protocol,
            param_callback=param_callback,
            fields=fields,
            xgafv=xgafv,
            pretty_print=pretty_print,
            access_token=access_token,
            alt=alt,
            channel_id=channel_id,
            channel_type=channel_type,
            event_type=event_type,
            for_content_owner=for_content_owner,
            for_developer=for_developer,
            for_mine=for_mine,
            location=location,
            location_radius=location_radius,
            max_results=max_results,
            on_behalf_of_content_owner=on_behalf_of_content_owner,
            order=order,
            page_token=page_token,
            published_after=published_after,
            published_before=published_before,
            q=q,
            region_code=region_code,
            relevance_language=relevance_language,
            safe_search=safe_search,
            topic_id=topic_id,
            type=type,
            video_caption=video_caption,
            video_category_id=video_category_id,
            video_definition=video_definition,
            video_dimension=video_dimension,
            video_duration=video_duration,
            video_embeddable=video_embeddable,
            video_license=video_license,
            video_paid_product_placement=video_paid_product_placement,
            video_syndicated=video_syndicated,
            video_type=video_type,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SearchListResponse",
        }
        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 youtube_search_list_with_http_info(
        self,
        part: Annotated[List[StrictStr], Field(description="The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet.")],
        oauth_token: Annotated[Optional[StrictStr], Field(description="OAuth 2.0 token for the current user.")] = None,
        key: Annotated[Optional[StrictStr], Field(description="API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.")] = None,
        upload_type: Annotated[Optional[StrictStr], Field(description="Legacy upload protocol for media (e.g. \"media\", \"multipart\").")] = None,
        quota_user: Annotated[Optional[StrictStr], Field(description="Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.")] = None,
        upload_protocol: Annotated[Optional[StrictStr], Field(description="Upload protocol for media (e.g. \"raw\", \"multipart\").")] = None,
        param_callback: Annotated[Optional[StrictStr], Field(description="JSONP")] = None,
        fields: Annotated[Optional[StrictStr], Field(description="Selector specifying which fields to include in a partial response.")] = None,
        xgafv: Annotated[Optional[StrictStr], Field(description="V1 error format.")] = None,
        pretty_print: Annotated[Optional[StrictBool], Field(description="Returns response with indentations and line breaks.")] = None,
        access_token: Annotated[Optional[StrictStr], Field(description="OAuth access token.")] = None,
        alt: Annotated[Optional[StrictStr], Field(description="Data format for response.")] = None,
        channel_id: Annotated[Optional[StrictStr], Field(description="Filter on resources belonging to this channelId.")] = None,
        channel_type: Annotated[Optional[StrictStr], Field(description="Add a filter on the channel search.")] = None,
        event_type: Annotated[Optional[StrictStr], Field(description="Filter on the livestream status of the videos.")] = None,
        for_content_owner: Annotated[Optional[StrictBool], Field(description="Search owned by a content owner.")] = None,
        for_developer: Annotated[Optional[StrictBool], Field(description="Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.")] = None,
        for_mine: Annotated[Optional[StrictBool], Field(description="Search for the private videos of the authenticated user.")] = None,
        location: Annotated[Optional[StrictStr], Field(description="Filter on location of the video")] = None,
        location_radius: Annotated[Optional[StrictStr], Field(description="Filter on distance from the location (specified above).")] = None,
        max_results: Annotated[Optional[Annotated[int, Field(le=50, strict=True, ge=0)]], Field(description="The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.")] = None,
        on_behalf_of_content_owner: Annotated[Optional[StrictStr], Field(description="*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.")] = None,
        order: Annotated[Optional[StrictStr], Field(description="Sort order of the results.")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.")] = None,
        published_after: Annotated[Optional[StrictStr], Field(description="Filter on resources published after this date.")] = None,
        published_before: Annotated[Optional[StrictStr], Field(description="Filter on resources published before this date.")] = None,
        q: Annotated[Optional[StrictStr], Field(description="Textual search terms to match.")] = None,
        region_code: Annotated[Optional[StrictStr], Field(description="Display the content as seen by viewers in this country.")] = None,
        relevance_language: Annotated[Optional[StrictStr], Field(description="Return results relevant to this language.")] = None,
        safe_search: Annotated[Optional[StrictStr], Field(description="Indicates whether the search results should include restricted content as well as standard content.")] = None,
        topic_id: Annotated[Optional[StrictStr], Field(description="Restrict results to a particular topic.")] = None,
        type: Annotated[Optional[List[StrictStr]], Field(description="Restrict results to a particular set of resource types from One Platform.")] = None,
        video_caption: Annotated[Optional[StrictStr], Field(description="Filter on the presence of captions on the videos.")] = None,
        video_category_id: Annotated[Optional[StrictStr], Field(description="Filter on videos in a specific category.")] = None,
        video_definition: Annotated[Optional[StrictStr], Field(description="Filter on the definition of the videos.")] = None,
        video_dimension: Annotated[Optional[StrictStr], Field(description="Filter on 3d videos.")] = None,
        video_duration: Annotated[Optional[StrictStr], Field(description="Filter on the duration of the videos.")] = None,
        video_embeddable: Annotated[Optional[StrictStr], Field(description="Filter on embeddable videos.")] = None,
        video_license: Annotated[Optional[StrictStr], Field(description="Filter on the license of the videos.")] = None,
        video_paid_product_placement: Optional[StrictStr] = None,
        video_syndicated: Annotated[Optional[StrictStr], Field(description="Filter on syndicated videos.")] = None,
        video_type: Annotated[Optional[StrictStr], Field(description="Filter on videos of a specific type.")] = None,
        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__: Optional[StrictStr] = None,
    ) -> ApiResponse[SearchListResponse]:
        """youtube_search_list

        Retrieves a list of search resources

        :param part: The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet. (required)
        :type part: List[str]
        :param oauth_token: OAuth 2.0 token for the current user.
        :type oauth_token: str
        :param key: API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
        :type key: str
        :param upload_type: Legacy upload protocol for media (e.g. \"media\", \"multipart\").
        :type upload_type: str
        :param quota_user: Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
        :type quota_user: str
        :param upload_protocol: Upload protocol for media (e.g. \"raw\", \"multipart\").
        :type upload_protocol: str
        :param param_callback: JSONP
        :type param_callback: str
        :param fields: Selector specifying which fields to include in a partial response.
        :type fields: str
        :param xgafv: V1 error format.
        :type xgafv: str
        :param pretty_print: Returns response with indentations and line breaks.
        :type pretty_print: bool
        :param access_token: OAuth access token.
        :type access_token: str
        :param alt: Data format for response.
        :type alt: str
        :param channel_id: Filter on resources belonging to this channelId.
        :type channel_id: str
        :param channel_type: Add a filter on the channel search.
        :type channel_type: str
        :param event_type: Filter on the livestream status of the videos.
        :type event_type: str
        :param for_content_owner: Search owned by a content owner.
        :type for_content_owner: bool
        :param for_developer: Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.
        :type for_developer: bool
        :param for_mine: Search for the private videos of the authenticated user.
        :type for_mine: bool
        :param location: Filter on location of the video
        :type location: str
        :param location_radius: Filter on distance from the location (specified above).
        :type location_radius: str
        :param max_results: The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.
        :type max_results: int
        :param on_behalf_of_content_owner: *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.
        :type on_behalf_of_content_owner: str
        :param order: Sort order of the results.
        :type order: str
        :param page_token: The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.
        :type page_token: str
        :param published_after: Filter on resources published after this date.
        :type published_after: str
        :param published_before: Filter on resources published before this date.
        :type published_before: str
        :param q: Textual search terms to match.
        :type q: str
        :param region_code: Display the content as seen by viewers in this country.
        :type region_code: str
        :param relevance_language: Return results relevant to this language.
        :type relevance_language: str
        :param safe_search: Indicates whether the search results should include restricted content as well as standard content.
        :type safe_search: str
        :param topic_id: Restrict results to a particular topic.
        :type topic_id: str
        :param type: Restrict results to a particular set of resource types from One Platform.
        :type type: List[str]
        :param video_caption: Filter on the presence of captions on the videos.
        :type video_caption: str
        :param video_category_id: Filter on videos in a specific category.
        :type video_category_id: str
        :param video_definition: Filter on the definition of the videos.
        :type video_definition: str
        :param video_dimension: Filter on 3d videos.
        :type video_dimension: str
        :param video_duration: Filter on the duration of the videos.
        :type video_duration: str
        :param video_embeddable: Filter on embeddable videos.
        :type video_embeddable: str
        :param video_license: Filter on the license of the videos.
        :type video_license: str
        :param video_paid_product_placement:
        :type video_paid_product_placement: str
        :param video_syndicated: Filter on syndicated videos.
        :type video_syndicated: str
        :param video_type: Filter on videos of a specific type.
        :type video_type: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._youtube_search_list_serialize(
            part=part,
            oauth_token=oauth_token,
            key=key,
            upload_type=upload_type,
            quota_user=quota_user,
            upload_protocol=upload_protocol,
            param_callback=param_callback,
            fields=fields,
            xgafv=xgafv,
            pretty_print=pretty_print,
            access_token=access_token,
            alt=alt,
            channel_id=channel_id,
            channel_type=channel_type,
            event_type=event_type,
            for_content_owner=for_content_owner,
            for_developer=for_developer,
            for_mine=for_mine,
            location=location,
            location_radius=location_radius,
            max_results=max_results,
            on_behalf_of_content_owner=on_behalf_of_content_owner,
            order=order,
            page_token=page_token,
            published_after=published_after,
            published_before=published_before,
            q=q,
            region_code=region_code,
            relevance_language=relevance_language,
            safe_search=safe_search,
            topic_id=topic_id,
            type=type,
            video_caption=video_caption,
            video_category_id=video_category_id,
            video_definition=video_definition,
            video_dimension=video_dimension,
            video_duration=video_duration,
            video_embeddable=video_embeddable,
            video_license=video_license,
            video_paid_product_placement=video_paid_product_placement,
            video_syndicated=video_syndicated,
            video_type=video_type,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SearchListResponse",
        }
        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 youtube_search_list_without_preload_content(
        self,
        part: Annotated[List[StrictStr], Field(description="The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet.")],
        oauth_token: Annotated[Optional[StrictStr], Field(description="OAuth 2.0 token for the current user.")] = None,
        key: Annotated[Optional[StrictStr], Field(description="API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.")] = None,
        upload_type: Annotated[Optional[StrictStr], Field(description="Legacy upload protocol for media (e.g. \"media\", \"multipart\").")] = None,
        quota_user: Annotated[Optional[StrictStr], Field(description="Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.")] = None,
        upload_protocol: Annotated[Optional[StrictStr], Field(description="Upload protocol for media (e.g. \"raw\", \"multipart\").")] = None,
        param_callback: Annotated[Optional[StrictStr], Field(description="JSONP")] = None,
        fields: Annotated[Optional[StrictStr], Field(description="Selector specifying which fields to include in a partial response.")] = None,
        xgafv: Annotated[Optional[StrictStr], Field(description="V1 error format.")] = None,
        pretty_print: Annotated[Optional[StrictBool], Field(description="Returns response with indentations and line breaks.")] = None,
        access_token: Annotated[Optional[StrictStr], Field(description="OAuth access token.")] = None,
        alt: Annotated[Optional[StrictStr], Field(description="Data format for response.")] = None,
        channel_id: Annotated[Optional[StrictStr], Field(description="Filter on resources belonging to this channelId.")] = None,
        channel_type: Annotated[Optional[StrictStr], Field(description="Add a filter on the channel search.")] = None,
        event_type: Annotated[Optional[StrictStr], Field(description="Filter on the livestream status of the videos.")] = None,
        for_content_owner: Annotated[Optional[StrictBool], Field(description="Search owned by a content owner.")] = None,
        for_developer: Annotated[Optional[StrictBool], Field(description="Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.")] = None,
        for_mine: Annotated[Optional[StrictBool], Field(description="Search for the private videos of the authenticated user.")] = None,
        location: Annotated[Optional[StrictStr], Field(description="Filter on location of the video")] = None,
        location_radius: Annotated[Optional[StrictStr], Field(description="Filter on distance from the location (specified above).")] = None,
        max_results: Annotated[Optional[Annotated[int, Field(le=50, strict=True, ge=0)]], Field(description="The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.")] = None,
        on_behalf_of_content_owner: Annotated[Optional[StrictStr], Field(description="*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.")] = None,
        order: Annotated[Optional[StrictStr], Field(description="Sort order of the results.")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.")] = None,
        published_after: Annotated[Optional[StrictStr], Field(description="Filter on resources published after this date.")] = None,
        published_before: Annotated[Optional[StrictStr], Field(description="Filter on resources published before this date.")] = None,
        q: Annotated[Optional[StrictStr], Field(description="Textual search terms to match.")] = None,
        region_code: Annotated[Optional[StrictStr], Field(description="Display the content as seen by viewers in this country.")] = None,
        relevance_language: Annotated[Optional[StrictStr], Field(description="Return results relevant to this language.")] = None,
        safe_search: Annotated[Optional[StrictStr], Field(description="Indicates whether the search results should include restricted content as well as standard content.")] = None,
        topic_id: Annotated[Optional[StrictStr], Field(description="Restrict results to a particular topic.")] = None,
        type: Annotated[Optional[List[StrictStr]], Field(description="Restrict results to a particular set of resource types from One Platform.")] = None,
        video_caption: Annotated[Optional[StrictStr], Field(description="Filter on the presence of captions on the videos.")] = None,
        video_category_id: Annotated[Optional[StrictStr], Field(description="Filter on videos in a specific category.")] = None,
        video_definition: Annotated[Optional[StrictStr], Field(description="Filter on the definition of the videos.")] = None,
        video_dimension: Annotated[Optional[StrictStr], Field(description="Filter on 3d videos.")] = None,
        video_duration: Annotated[Optional[StrictStr], Field(description="Filter on the duration of the videos.")] = None,
        video_embeddable: Annotated[Optional[StrictStr], Field(description="Filter on embeddable videos.")] = None,
        video_license: Annotated[Optional[StrictStr], Field(description="Filter on the license of the videos.")] = None,
        video_paid_product_placement: Optional[StrictStr] = None,
        video_syndicated: Annotated[Optional[StrictStr], Field(description="Filter on syndicated videos.")] = None,
        video_type: Annotated[Optional[StrictStr], Field(description="Filter on videos of a specific type.")] = None,
        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__: Optional[StrictStr] = None,
    ) -> RESTResponseType:
        """youtube_search_list

        Retrieves a list of search resources

        :param part: The *part* parameter specifies a comma-separated list of one or more search resource properties that the API response will include. Set the parameter value to snippet. (required)
        :type part: List[str]
        :param oauth_token: OAuth 2.0 token for the current user.
        :type oauth_token: str
        :param key: API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
        :type key: str
        :param upload_type: Legacy upload protocol for media (e.g. \"media\", \"multipart\").
        :type upload_type: str
        :param quota_user: Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
        :type quota_user: str
        :param upload_protocol: Upload protocol for media (e.g. \"raw\", \"multipart\").
        :type upload_protocol: str
        :param param_callback: JSONP
        :type param_callback: str
        :param fields: Selector specifying which fields to include in a partial response.
        :type fields: str
        :param xgafv: V1 error format.
        :type xgafv: str
        :param pretty_print: Returns response with indentations and line breaks.
        :type pretty_print: bool
        :param access_token: OAuth access token.
        :type access_token: str
        :param alt: Data format for response.
        :type alt: str
        :param channel_id: Filter on resources belonging to this channelId.
        :type channel_id: str
        :param channel_type: Add a filter on the channel search.
        :type channel_type: str
        :param event_type: Filter on the livestream status of the videos.
        :type event_type: str
        :param for_content_owner: Search owned by a content owner.
        :type for_content_owner: bool
        :param for_developer: Restrict the search to only retrieve videos uploaded using the project id of the authenticated user.
        :type for_developer: bool
        :param for_mine: Search for the private videos of the authenticated user.
        :type for_mine: bool
        :param location: Filter on location of the video
        :type location: str
        :param location_radius: Filter on distance from the location (specified above).
        :type location_radius: str
        :param max_results: The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.
        :type max_results: int
        :param on_behalf_of_content_owner: *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.
        :type on_behalf_of_content_owner: str
        :param order: Sort order of the results.
        :type order: str
        :param page_token: The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.
        :type page_token: str
        :param published_after: Filter on resources published after this date.
        :type published_after: str
        :param published_before: Filter on resources published before this date.
        :type published_before: str
        :param q: Textual search terms to match.
        :type q: str
        :param region_code: Display the content as seen by viewers in this country.
        :type region_code: str
        :param relevance_language: Return results relevant to this language.
        :type relevance_language: str
        :param safe_search: Indicates whether the search results should include restricted content as well as standard content.
        :type safe_search: str
        :param topic_id: Restrict results to a particular topic.
        :type topic_id: str
        :param type: Restrict results to a particular set of resource types from One Platform.
        :type type: List[str]
        :param video_caption: Filter on the presence of captions on the videos.
        :type video_caption: str
        :param video_category_id: Filter on videos in a specific category.
        :type video_category_id: str
        :param video_definition: Filter on the definition of the videos.
        :type video_definition: str
        :param video_dimension: Filter on 3d videos.
        :type video_dimension: str
        :param video_duration: Filter on the duration of the videos.
        :type video_duration: str
        :param video_embeddable: Filter on embeddable videos.
        :type video_embeddable: str
        :param video_license: Filter on the license of the videos.
        :type video_license: str
        :param video_paid_product_placement:
        :type video_paid_product_placement: str
        :param video_syndicated: Filter on syndicated videos.
        :type video_syndicated: str
        :param video_type: Filter on videos of a specific type.
        :type video_type: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._youtube_search_list_serialize(
            part=part,
            oauth_token=oauth_token,
            key=key,
            upload_type=upload_type,
            quota_user=quota_user,
            upload_protocol=upload_protocol,
            param_callback=param_callback,
            fields=fields,
            xgafv=xgafv,
            pretty_print=pretty_print,
            access_token=access_token,
            alt=alt,
            channel_id=channel_id,
            channel_type=channel_type,
            event_type=event_type,
            for_content_owner=for_content_owner,
            for_developer=for_developer,
            for_mine=for_mine,
            location=location,
            location_radius=location_radius,
            max_results=max_results,
            on_behalf_of_content_owner=on_behalf_of_content_owner,
            order=order,
            page_token=page_token,
            published_after=published_after,
            published_before=published_before,
            q=q,
            region_code=region_code,
            relevance_language=relevance_language,
            safe_search=safe_search,
            topic_id=topic_id,
            type=type,
            video_caption=video_caption,
            video_category_id=video_category_id,
            video_definition=video_definition,
            video_dimension=video_dimension,
            video_duration=video_duration,
            video_embeddable=video_embeddable,
            video_license=video_license,
            video_paid_product_placement=video_paid_product_placement,
            video_syndicated=video_syndicated,
            video_type=video_type,
            request_auth__=request_auth__,
            content_type__=content_type__,
            headers__=headers__,
            host__=host__
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SearchListResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            request_timeout__=request_timeout__
        )
        return response_data.response


    def _youtube_search_list_serialize(
        self,
        part,
        oauth_token,
        key,
        upload_type,
        quota_user,
        upload_protocol,
        param_callback,
        fields,
        xgafv,
        pretty_print,
        access_token,
        alt,
        channel_id,
        channel_type,
        event_type,
        for_content_owner,
        for_developer,
        for_mine,
        location,
        location_radius,
        max_results,
        on_behalf_of_content_owner,
        order,
        page_token,
        published_after,
        published_before,
        q,
        region_code,
        relevance_language,
        safe_search,
        topic_id,
        type,
        video_caption,
        video_category_id,
        video_definition,
        video_dimension,
        video_duration,
        video_embeddable,
        video_license,
        video_paid_product_placement,
        video_syndicated,
        video_type,
        request_auth__,
        content_type__,
        headers__,
        host__,
    ) -> RequestSerialized:


        _collection_formats: Dict[str, str] = {
            'part': 'multi',
            'type': 'multi',
        }

        _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
        # process the query parameters
        if oauth_token is not None:
            
            _query_params.append(('oauth_token', oauth_token))
            
        if key is not None:
            
            _query_params.append(('key', key))
            
        if upload_type is not None:
            
            _query_params.append(('uploadType', upload_type))
            
        if quota_user is not None:
            
            _query_params.append(('quotaUser', quota_user))
            
        if upload_protocol is not None:
            
            _query_params.append(('upload_protocol', upload_protocol))
            
        if param_callback is not None:
            
            _query_params.append(('callback', param_callback))
            
        if fields is not None:
            
            _query_params.append(('fields', fields))
            
        if xgafv is not None:
            
            _query_params.append(('$.xgafv', xgafv))
            
        if pretty_print is not None:
            
            _query_params.append(('prettyPrint', pretty_print))
            
        if access_token is not None:
            
            _query_params.append(('access_token', access_token))
            
        if alt is not None:
            
            _query_params.append(('alt', alt))
            
        if part is not None:
            
            _query_params.append(('part', part))
            
        if channel_id is not None:
            
            _query_params.append(('channelId', channel_id))
            
        if channel_type is not None:
            
            _query_params.append(('channelType', channel_type))
            
        if event_type is not None:
            
            _query_params.append(('eventType', event_type))
            
        if for_content_owner is not None:
            
            _query_params.append(('forContentOwner', for_content_owner))
            
        if for_developer is not None:
            
            _query_params.append(('forDeveloper', for_developer))
            
        if for_mine is not None:
            
            _query_params.append(('forMine', for_mine))
            
        if location is not None:
            
            _query_params.append(('location', location))
            
        if location_radius is not None:
            
            _query_params.append(('locationRadius', location_radius))
            
        if max_results is not None:
            
            _query_params.append(('maxResults', max_results))
            
        if on_behalf_of_content_owner is not None:
            
            _query_params.append(('onBehalfOfContentOwner', on_behalf_of_content_owner))
            
        if order is not None:
            
            _query_params.append(('order', order))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if published_after is not None:
            
            _query_params.append(('publishedAfter', published_after))
            
        if published_before is not None:
            
            _query_params.append(('publishedBefore', published_before))
            
        if q is not None:
            
            _query_params.append(('q', q))
            
        if region_code is not None:
            
            _query_params.append(('regionCode', region_code))
            
        if relevance_language is not None:
            
            _query_params.append(('relevanceLanguage', relevance_language))
            
        if safe_search is not None:
            
            _query_params.append(('safeSearch', safe_search))
            
        if topic_id is not None:
            
            _query_params.append(('topicId', topic_id))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if video_caption is not None:
            
            _query_params.append(('videoCaption', video_caption))
            
        if video_category_id is not None:
            
            _query_params.append(('videoCategoryId', video_category_id))
            
        if video_definition is not None:
            
            _query_params.append(('videoDefinition', video_definition))
            
        if video_dimension is not None:
            
            _query_params.append(('videoDimension', video_dimension))
            
        if video_duration is not None:
            
            _query_params.append(('videoDuration', video_duration))
            
        if video_embeddable is not None:
            
            _query_params.append(('videoEmbeddable', video_embeddable))
            
        if video_license is not None:
            
            _query_params.append(('videoLicense', video_license))
            
        if video_paid_product_placement is not None:
            
            _query_params.append(('videoPaidProductPlacement', video_paid_product_placement))
            
        if video_syndicated is not None:
            
            _query_params.append(('videoSyndicated', video_syndicated))
            
        if video_type is not None:
            
            _query_params.append(('videoType', video_type))
            
        # 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(
                [
                    '*/*'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'Oauth2c', 
            'Oauth2'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/youtube/v3/search',
            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__
        )


