{"files":{"SKILL.md":"---\nname: youtube-data-api-v3\ndescription: \"YouTube Data API v3 API skill. Use when working with YouTube Data API v3 for youtube. Covers 76 endpoints.\"\nversion: 1.0.0\ngenerator: lapsh\n---\n\n# YouTube Data API v3\nAPI version: v3\n\n## Auth\nOAuth2 | OAuth2\n\n## Base URL\nhttps://youtube.googleapis.com/\n\n## Setup\n1. Configure auth: OAuth2 | OAuth2\n2. GET /youtube/v3/activities -- retrieves a list of resources, possibly filtered.\n3. POST /youtube/v3/abuseReports -- create first abuseReport\n\n## Endpoints\n76 endpoints across 1 group. See references/api-spec.lap for full details.\n\n### Youtube\n| Method | Path | Description |\n|--------|------|-------------|\n| POST | /youtube/v3/abuseReports | Inserts a new resource into this collection. |\n| GET | /youtube/v3/activities | Retrieves a list of resources, possibly filtered. |\n| DELETE | /youtube/v3/captions | Deletes a resource. |\n| GET | /youtube/v3/captions | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/captions | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/captions | Updates an existing resource. |\n| GET | /youtube/v3/captions/{id} | Downloads a caption track. |\n| POST | /youtube/v3/channelBanners/insert | Inserts a new resource into this collection. |\n| DELETE | /youtube/v3/channelSections | Deletes a resource. |\n| GET | /youtube/v3/channelSections | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/channelSections | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/channelSections | Updates an existing resource. |\n| GET | /youtube/v3/channels | Retrieves a list of resources, possibly filtered. |\n| PUT | /youtube/v3/channels | Updates an existing resource. |\n| GET | /youtube/v3/commentThreads | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/commentThreads | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/commentThreads | Updates an existing resource. |\n| DELETE | /youtube/v3/comments | Deletes a resource. |\n| GET | /youtube/v3/comments | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/comments | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/comments | Updates an existing resource. |\n| POST | /youtube/v3/comments/markAsSpam | Expresses the caller's opinion that one or more comments should be flagged as spam. |\n| POST | /youtube/v3/comments/setModerationStatus | Sets the moderation status of one or more comments. |\n| GET | /youtube/v3/i18nLanguages | Retrieves a list of resources, possibly filtered. |\n| GET | /youtube/v3/i18nRegions | Retrieves a list of resources, possibly filtered. |\n| DELETE | /youtube/v3/liveBroadcasts | Delete a given broadcast. |\n| GET | /youtube/v3/liveBroadcasts | Retrieve the list of broadcasts associated with the given channel. |\n| POST | /youtube/v3/liveBroadcasts | Inserts a new stream for the authenticated user. |\n| PUT | /youtube/v3/liveBroadcasts | Updates an existing broadcast for the authenticated user. |\n| POST | /youtube/v3/liveBroadcasts/bind | Bind a broadcast to a stream. |\n| POST | /youtube/v3/liveBroadcasts/cuepoint | Insert cuepoints in a broadcast |\n| POST | /youtube/v3/liveBroadcasts/transition | Transition a broadcast to a given status. |\n| DELETE | /youtube/v3/liveChat/bans | Deletes a chat ban. |\n| POST | /youtube/v3/liveChat/bans | Inserts a new resource into this collection. |\n| DELETE | /youtube/v3/liveChat/messages | Deletes a chat message. |\n| GET | /youtube/v3/liveChat/messages | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/liveChat/messages | Inserts a new resource into this collection. |\n| DELETE | /youtube/v3/liveChat/moderators | Deletes a chat moderator. |\n| GET | /youtube/v3/liveChat/moderators | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/liveChat/moderators | Inserts a new resource into this collection. |\n| DELETE | /youtube/v3/liveStreams | Deletes an existing stream for the authenticated user. |\n| GET | /youtube/v3/liveStreams | Retrieve the list of streams associated with the given channel. -- |\n| POST | /youtube/v3/liveStreams | Inserts a new stream for the authenticated user. |\n| PUT | /youtube/v3/liveStreams | Updates an existing stream for the authenticated user. |\n| GET | /youtube/v3/members | Retrieves a list of members that match the request criteria for a channel. |\n| GET | /youtube/v3/membershipsLevels | Retrieves a list of all pricing levels offered by a creator to the fans. |\n| DELETE | /youtube/v3/playlistItems | Deletes a resource. |\n| GET | /youtube/v3/playlistItems | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/playlistItems | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/playlistItems | Updates an existing resource. |\n| DELETE | /youtube/v3/playlists | Deletes a resource. |\n| GET | /youtube/v3/playlists | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/playlists | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/playlists | Updates an existing resource. |\n| GET | /youtube/v3/search | Retrieves a list of search resources |\n| DELETE | /youtube/v3/subscriptions | Deletes a resource. |\n| GET | /youtube/v3/subscriptions | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/subscriptions | Inserts a new resource into this collection. |\n| GET | /youtube/v3/superChatEvents | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/tests | POST method. |\n| DELETE | /youtube/v3/thirdPartyLinks | Deletes a resource. |\n| GET | /youtube/v3/thirdPartyLinks | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/thirdPartyLinks | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/thirdPartyLinks | Updates an existing resource. |\n| POST | /youtube/v3/thumbnails/set | As this is not an insert in a strict sense (it supports uploading/setting of a thumbnail for multiple videos, which doesn't result in creation of a single resource), I use a custom verb here. |\n| GET | /youtube/v3/videoAbuseReportReasons | Retrieves a list of resources, possibly filtered. |\n| GET | /youtube/v3/videoCategories | Retrieves a list of resources, possibly filtered. |\n| DELETE | /youtube/v3/videos | Deletes a resource. |\n| GET | /youtube/v3/videos | Retrieves a list of resources, possibly filtered. |\n| POST | /youtube/v3/videos | Inserts a new resource into this collection. |\n| PUT | /youtube/v3/videos | Updates an existing resource. |\n| GET | /youtube/v3/videos/getRating | Retrieves the ratings that the authorized user gave to a list of specified videos. |\n| POST | /youtube/v3/videos/rate | Adds a like or dislike rating to a video or removes a rating from a video. |\n| POST | /youtube/v3/videos/reportAbuse | Report abuse for a video. |\n| POST | /youtube/v3/watermarks/set | Allows upload of watermark image and setting it for a channel. |\n| POST | /youtube/v3/watermarks/unset | Allows removal of channel watermark. |\n\n## Common Questions\nMatch user requests to endpoints in references/api-spec.lap. Key patterns:\n- \"Create a abuseReport?\" -> POST /youtube/v3/abuseReports\n- \"List all activities?\" -> GET /youtube/v3/activities\n- \"List all captions?\" -> GET /youtube/v3/captions\n- \"Create a caption?\" -> POST /youtube/v3/captions\n- \"Get caption details?\" -> GET /youtube/v3/captions/{id}\n- \"Create a insert?\" -> POST /youtube/v3/channelBanners/insert\n- \"List all channelSections?\" -> GET /youtube/v3/channelSections\n- \"Create a channelSection?\" -> POST /youtube/v3/channelSections\n- \"List all channels?\" -> GET /youtube/v3/channels\n- \"List all commentThreads?\" -> GET /youtube/v3/commentThreads\n- \"Create a commentThread?\" -> POST /youtube/v3/commentThreads\n- \"List all comments?\" -> GET /youtube/v3/comments\n- \"Create a comment?\" -> POST /youtube/v3/comments\n- \"Create a markAsSpam?\" -> POST /youtube/v3/comments/markAsSpam\n- \"Create a setModerationStatus?\" -> POST /youtube/v3/comments/setModerationStatus\n- \"List all i18nLanguages?\" -> GET /youtube/v3/i18nLanguages\n- \"List all i18nRegions?\" -> GET /youtube/v3/i18nRegions\n- \"List all liveBroadcasts?\" -> GET /youtube/v3/liveBroadcasts\n- \"Create a liveBroadcast?\" -> POST /youtube/v3/liveBroadcasts\n- \"Create a bind?\" -> POST /youtube/v3/liveBroadcasts/bind\n- \"Create a cuepoint?\" -> POST /youtube/v3/liveBroadcasts/cuepoint\n- \"Create a transition?\" -> POST /youtube/v3/liveBroadcasts/transition\n- \"Create a ban?\" -> POST /youtube/v3/liveChat/bans\n- \"List all messages?\" -> GET /youtube/v3/liveChat/messages\n- \"Create a message?\" -> POST /youtube/v3/liveChat/messages\n- \"List all moderators?\" -> GET /youtube/v3/liveChat/moderators\n- \"Create a moderator?\" -> POST /youtube/v3/liveChat/moderators\n- \"List all liveStreams?\" -> GET /youtube/v3/liveStreams\n- \"Create a liveStream?\" -> POST /youtube/v3/liveStreams\n- \"List all members?\" -> GET /youtube/v3/members\n- \"List all membershipsLevels?\" -> GET /youtube/v3/membershipsLevels\n- \"List all playlistItems?\" -> GET /youtube/v3/playlistItems\n- \"Create a playlistItem?\" -> POST /youtube/v3/playlistItems\n- \"List all playlists?\" -> GET /youtube/v3/playlists\n- \"Create a playlist?\" -> POST /youtube/v3/playlists\n- \"Search search?\" -> GET /youtube/v3/search\n- \"List all subscriptions?\" -> GET /youtube/v3/subscriptions\n- \"Create a subscription?\" -> POST /youtube/v3/subscriptions\n- \"List all superChatEvents?\" -> GET /youtube/v3/superChatEvents\n- \"Create a test?\" -> POST /youtube/v3/tests\n- \"List all thirdPartyLinks?\" -> GET /youtube/v3/thirdPartyLinks\n- \"Create a thirdPartyLink?\" -> POST /youtube/v3/thirdPartyLinks\n- \"Create a set?\" -> POST /youtube/v3/thumbnails/set\n- \"List all videoAbuseReportReasons?\" -> GET /youtube/v3/videoAbuseReportReasons\n- \"List all videoCategories?\" -> GET /youtube/v3/videoCategories\n- \"List all videos?\" -> GET /youtube/v3/videos\n- \"Create a video?\" -> POST /youtube/v3/videos\n- \"List all getRating?\" -> GET /youtube/v3/videos/getRating\n- \"Create a rate?\" -> POST /youtube/v3/videos/rate\n- \"Create a reportAbuse?\" -> POST /youtube/v3/videos/reportAbuse\n- \"Create a unset?\" -> POST /youtube/v3/watermarks/unset\n- \"How to authenticate?\" -> See Auth section above\n\n## Response Tips\n- Check response schemas in references/api-spec.lap for field details\n- Create/update endpoints return the modified resource on success\n\n## References\n- Full spec: See references/api-spec.lap for complete endpoint details, parameter tables, and response schemas\n\n> Generated from the official API spec by [LAP](https://lap.sh)\n","references/api-spec.lap":"@lap v0.3\n# Machine-readable API spec. Each @endpoint block is one API call.\n@api YouTube Data API v3\n@base https://youtube.googleapis.com/\n@version v3\n@auth OAuth2 | OAuth2\n@endpoints 76\n@hint download_for_search\n@toc youtube(76)\n\n@endpoint POST /youtube/v3/abuseReports\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.}\n@optional {abuseTypes: [map{id: str}], description: str, relatedEntities: [map{entity: map}], subject: map{id: str, typeId: str, url: str}}\n@returns(200) {abuseTypes: [map], description: str, relatedEntities: [map], subject: map{id: str, typeId: str, url: str}} # Successful response\n\n@endpoint GET /youtube/v3/activities\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more activity resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in an activity resource, the snippet property contains other properties that identify the type of activity, a display title for the activity, and so forth. If you set *part=snippet*, the API response will also contain all of those nested properties.}\n@optional {channelId: str, home: bool, maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool, pageToken: str # 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., publishedAfter: str, publishedBefore: str, regionCode: str}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint DELETE /youtube/v3/captions\n@desc Deletes a resource.\n@required {id: str}\n@optional {onBehalfOf: str # ID of the Google+ Page for the channel that the request is be on behalf of, onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/captions\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more caption resource parts that the API response will include. The part names that you can include in the parameter value are id and snippet., videoId: str # Returns the captions for the specified video.}\n@optional {id: [str] # Returns the captions with the given IDs for Stubby or Apiary., onBehalfOf: str # ID of the Google+ Page for the channel that the request is on behalf of., onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/captions\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter specifies the caption resource parts that the API response will include. Set the parameter value to snippet.}\n@optional {onBehalfOf: str # ID of the Google+ Page for the channel that the request is be on behalf of, onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner., sync: bool # Extra parameter to allow automatically syncing the uploaded caption/transcript with the audio.}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{audioTrackType: str, failureReason: str, isAutoSynced: bool, isCC: bool, isDraft: bool, isEasyReader: bool, isLarge: bool, language: str, lastUpdated: str(date-time), name: str, status: str, trackKind: str, videoId: str}} # Successful response\n\n@endpoint PUT /youtube/v3/captions\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more caption resource parts that the API response will include. The part names that you can include in the parameter value are id and snippet.}\n@optional {onBehalfOf: str # ID of the Google+ Page for the channel that the request is on behalf of., onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner., sync: bool # Extra parameter to allow automatically syncing the uploaded caption/transcript with the audio.}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{audioTrackType: str, failureReason: str, isAutoSynced: bool, isCC: bool, isDraft: bool, isEasyReader: bool, isLarge: bool, language: str, lastUpdated: str(date-time), name: str, status: str, trackKind: str, videoId: str}} # Successful response\n\n@endpoint GET /youtube/v3/captions/{id}\n@desc Downloads a caption track.\n@required {id: str # The ID of the caption track to download, required for One Platform.}\n@optional {onBehalfOf: str # ID of the Google+ Page for the channel that the request is be on behalf of, onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner., tfmt: str # Convert the captions into this format. Supported options are sbv, srt, and vtt., tlang: str # tlang is the language code; machine translate the captions into this language.}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/channelBanners/insert\n@desc Inserts a new resource into this collection.\n@optional {channelId: str # Unused, channel_id is currently derived from the security context of the requestor., onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.}\n@returns(200) {etag: str, kind: str, url: str} # Successful response\n\n@endpoint DELETE /youtube/v3/channelSections\n@desc Deletes a resource.\n@required {id: str}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/channelSections\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more channelSection resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, and contentDetails. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channelSection resource, the snippet property contains other properties, such as a display title for the channelSection. If you set *part=snippet*, the API response will also contain all of those nested properties.}\n@optional {channelId: str # Return the ChannelSections owned by the specified channel ID., hl: str # Return content in specified language, id: [str] # Return the ChannelSections with the given IDs for Stubby or Apiary., mine: bool # Return the ChannelSections owned by the authenticated user., onBehalfOfContentOwner: str # *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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/channelSections\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part names that you can include in the parameter value are snippet and contentDetails.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., contentDetails: map{channels: [str], playlists: [str]} # Details about a channelsection, including playlists and channels., etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the channel section., kind: str=youtube#channelSection # Identifies what kind of resource this is. Value: the fixed string \"youtube#channelSection\"., localizations: map # Localizations for different languages, snippet: map{channelId: str, defaultLanguage: str, localized: map, position: int(uint32), style: str, title: str, type: str} # Basic details about a channel section, including title, style and position., targeting: map{countries: [str], languages: [str], regions: [str]} # ChannelSection targeting setting.}\n@returns(200) {contentDetails: map{channels: [str], playlists: [str]}, etag: str, id: str, kind: str, localizations: map, snippet: map{channelId: str, defaultLanguage: str, localized: map{title: str}, position: int(uint32), style: str, title: str, type: str}, targeting: map{countries: [str], languages: [str], regions: [str]}} # Successful response\n\n@endpoint PUT /youtube/v3/channelSections\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part names that you can include in the parameter value are snippet and contentDetails.}\n@optional {onBehalfOfContentOwner: str # *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., contentDetails: map{channels: [str], playlists: [str]} # Details about a channelsection, including playlists and channels., etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the channel section., kind: str=youtube#channelSection # Identifies what kind of resource this is. Value: the fixed string \"youtube#channelSection\"., localizations: map # Localizations for different languages, snippet: map{channelId: str, defaultLanguage: str, localized: map, position: int(uint32), style: str, title: str, type: str} # Basic details about a channel section, including title, style and position., targeting: map{countries: [str], languages: [str], regions: [str]} # ChannelSection targeting setting.}\n@returns(200) {contentDetails: map{channels: [str], playlists: [str]}, etag: str, id: str, kind: str, localizations: map, snippet: map{channelId: str, defaultLanguage: str, localized: map{title: str}, position: int(uint32), style: str, title: str, type: str}, targeting: map{countries: [str], languages: [str], regions: [str]}} # Successful response\n\n@endpoint GET /youtube/v3/channels\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more channel resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a channel resource, the contentDetails property contains other properties, such as the uploads properties. As such, if you set *part=contentDetails*, the API response will also contain all of those nested properties.}\n@optional {categoryId: str # Return the channels within the specified guide category ID., forUsername: str # Return the channel associated with a YouTube username., hl: str # Stands for \"host language\". Specifies the localization language of the metadata to be filled into snippet.localized. The field is filled with the default metadata if there is no localization in the specified language. The parameter value must be a language code included in the list returned by the i18nLanguages.list method (e.g. en_US, es_MX)., id: [str] # Return the channels with the specified IDs., managedByMe: bool # Return the channels managed by the authenticated user., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool # Return the ids of channels owned by the authenticated user., mySubscribers: bool # Return the channels subscribed to the authenticated user, onBehalfOfContentOwner: str # *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., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint PUT /youtube/v3/channels\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The API currently only allows the parameter value to be set to either brandingSettings or invideoPromotion. (You cannot update both of those parts with a single request.) Note that this method overrides the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies.}\n@optional {onBehalfOfContentOwner: str # The *onBehalfOfContentOwner* parameter indicates that the authenticated user 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 actual CMS account that the user authenticates with needs to be linked to the specified YouTube content owner., auditDetails: map{communityGuidelinesGoodStanding: bool, contentIdClaimsGoodStanding: bool, copyrightStrikesGoodStanding: bool} # The auditDetails object encapsulates channel data that is relevant for YouTube Partners during the audit process., brandingSettings: map{channel: map, hints: [map], image: map, watch: map} # Branding properties of a YouTube channel., contentDetails: map{relatedPlaylists: map} # Details about the content of a channel., contentOwnerDetails: map{contentOwner: str, timeLinked: str(date-time)} # The contentOwnerDetails object encapsulates channel data that is relevant for YouTube Partners linked with the channel., conversionPings: map{pings: [map]} # The conversionPings object encapsulates information about conversion pings that need to be respected by the channel., etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the channel., kind: str=youtube#channel # Identifies what kind of resource this is. Value: the fixed string \"youtube#channel\"., localizations: map # Localizations for different languages, snippet: map{country: str, customUrl: str, defaultLanguage: str, description: str, localized: map, publishedAt: str(date-time), thumbnails: map, title: str} # Basic details about a channel, including title, description and thumbnails., statistics: map{commentCount: str(uint64), hiddenSubscriberCount: bool, subscriberCount: str(uint64), videoCount: str(uint64), viewCount: str(uint64)} # Statistics about a channel: number of subscribers, number of videos in the channel, etc., status: map{isLinked: bool, longUploadsStatus: str, madeForKids: bool, privacyStatus: str, selfDeclaredMadeForKids: bool} # JSON template for the status part of a channel., topicDetails: map{topicCategories: [str], topicIds: [str]} # Freebase topic information related to the channel.}\n@returns(200) {auditDetails: map{communityGuidelinesGoodStanding: bool, contentIdClaimsGoodStanding: bool, copyrightStrikesGoodStanding: bool}, brandingSettings: map{channel: map{country: str, defaultLanguage: str, defaultTab: str, description: str, featuredChannelsTitle: str, featuredChannelsUrls: [str], keywords: str, moderateComments: bool, profileColor: str, showBrowseView: bool, showRelatedChannels: bool, title: str, trackingAnalyticsAccountId: str, unsubscribedTrailer: str}, hints: [map], image: map{backgroundImageUrl: map{defaultLanguage: map, localized: [map]}, bannerExternalUrl: str, bannerImageUrl: str, bannerMobileExtraHdImageUrl: str, bannerMobileHdImageUrl: str, bannerMobileImageUrl: str, bannerMobileLowImageUrl: str, bannerMobileMediumHdImageUrl: str, bannerTabletExtraHdImageUrl: str, bannerTabletHdImageUrl: str, bannerTabletImageUrl: str, bannerTabletLowImageUrl: str, bannerTvHighImageUrl: str, bannerTvImageUrl: str, bannerTvLowImageUrl: str, bannerTvMediumImageUrl: str, largeBrandedBannerImageImapScript: map{defaultLanguage: map, localized: [map]}, largeBrandedBannerImageUrl: map{defaultLanguage: map, localized: [map]}, smallBrandedBannerImageImapScript: map{defaultLanguage: map, localized: [map]}, smallBrandedBannerImageUrl: map{defaultLanguage: map, localized: [map]}, trackingImageUrl: str, watchIconImageUrl: str}, watch: map{backgroundColor: str, featuredPlaylistId: str, textColor: str}}, contentDetails: map{relatedPlaylists: map{favorites: str, likes: str, uploads: str, watchHistory: str, watchLater: str}}, contentOwnerDetails: map{contentOwner: str, timeLinked: str(date-time)}, conversionPings: map{pings: [map]}, etag: str, id: str, kind: str, localizations: map, snippet: map{country: str, customUrl: str, defaultLanguage: str, description: str, localized: map{description: str, title: str}, publishedAt: str(date-time), thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{commentCount: str(uint64), hiddenSubscriberCount: bool, subscriberCount: str(uint64), videoCount: str(uint64), viewCount: str(uint64)}, status: map{isLinked: bool, longUploadsStatus: str, madeForKids: bool, privacyStatus: str, selfDeclaredMadeForKids: bool}, topicDetails: map{topicCategories: [str], topicIds: [str]}} # Successful response\n\n@endpoint GET /youtube/v3/commentThreads\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more commentThread resource properties that the API response will include.}\n@optional {allThreadsRelatedToChannelId: str # Returns the comment threads of all videos of the channel and the channel comments as well., channelId: str # Returns the comment threads for all the channel comments (ie does not include comments left on videos)., id: [str] # Returns the comment threads with the given IDs for Stubby or Apiary., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., moderationStatus: str(published/heldForReview/likelySpam/rejected) # Limits the returned comment threads to those with the specified moderation status. Not compatible with the 'id' filter. Valid values: published, heldForReview, likelySpam., order: str(orderUnspecified/time/relevance), pageToken: str # 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., searchTerms: str # Limits the returned comment threads to those matching the specified key words. Not compatible with the 'id' filter., textFormat: str(textFormatUnspecified/html/plainText) # The requested text format for the returned comments., videoId: str # Returns the comment threads of the specified video.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/commentThreads\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter identifies the properties that the API response will include. Set the parameter value to snippet. The snippet part has a quota cost of 2 units.}\n@optional {etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the comment thread., kind: str=youtube#commentThread # Identifies what kind of resource this is. Value: the fixed string \"youtube#commentThread\"., replies: map{comments: [map]} # Comments written in (direct or indirect) reply to the top level comment., snippet: map{canReply: bool, channelId: str, isPublic: bool, topLevelComment: map, totalReplyCount: int(uint32), videoId: str} # Basic details about a comment thread.}\n@returns(200) {etag: str, id: str, kind: str, replies: map{comments: [map]}, snippet: map{canReply: bool, channelId: str, isPublic: bool, topLevelComment: map{etag: str, id: str, kind: str, snippet: map{authorChannelId: map, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str}}, totalReplyCount: int(uint32), videoId: str}} # Successful response\n\n@endpoint PUT /youtube/v3/commentThreads\n@desc Updates an existing resource.\n@optional {part: [str] # The *part* parameter specifies a comma-separated list of commentThread resource properties that the API response will include. You must at least include the snippet part in the parameter value since that part contains all of the properties that the API request can update., etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the comment thread., kind: str=youtube#commentThread # Identifies what kind of resource this is. Value: the fixed string \"youtube#commentThread\"., replies: map{comments: [map]} # Comments written in (direct or indirect) reply to the top level comment., snippet: map{canReply: bool, channelId: str, isPublic: bool, topLevelComment: map, totalReplyCount: int(uint32), videoId: str} # Basic details about a comment thread.}\n@returns(200) {etag: str, id: str, kind: str, replies: map{comments: [map]}, snippet: map{canReply: bool, channelId: str, isPublic: bool, topLevelComment: map{etag: str, id: str, kind: str, snippet: map{authorChannelId: map, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str}}, totalReplyCount: int(uint32), videoId: str}} # Successful response\n\n@endpoint DELETE /youtube/v3/comments\n@desc Deletes a resource.\n@required {id: str}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/comments\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more comment resource properties that the API response will include.}\n@optional {id: [str] # Returns the comments with the given IDs for One Platform., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., pageToken: str # 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., parentId: str # Returns replies to the specified comment. Note, currently YouTube features only one level of replies (ie replies to top level comments). However replies to replies may be supported in the future., textFormat: str(textFormatUnspecified/html/plainText) # The requested text format for the returned comments.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/comments\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter identifies the properties that the API response will include. Set the parameter value to snippet. The snippet part has a quota cost of 2 units.}\n@optional {etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the comment., kind: str=youtube#comment # Identifies what kind of resource this is. Value: the fixed string \"youtube#comment\"., snippet: map{authorChannelId: map, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str} # Basic details about a comment, such as its author and text.}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{authorChannelId: map{value: str}, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str}} # Successful response\n\n@endpoint PUT /youtube/v3/comments\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter identifies the properties that the API response will include. You must at least include the snippet part in the parameter value since that part contains all of the properties that the API request can update.}\n@optional {etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the comment., kind: str=youtube#comment # Identifies what kind of resource this is. Value: the fixed string \"youtube#comment\"., snippet: map{authorChannelId: map, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str} # Basic details about a comment, such as its author and text.}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{authorChannelId: map{value: str}, authorChannelUrl: str, authorDisplayName: str, authorProfileImageUrl: str, canRate: bool, channelId: str, likeCount: int(uint32), moderationStatus: str, parentId: str, publishedAt: str(date-time), textDisplay: str, textOriginal: str, updatedAt: str(date-time), videoId: str, viewerRating: str}} # Successful response\n\n@endpoint POST /youtube/v3/comments/markAsSpam\n@desc Expresses the caller's opinion that one or more comments should be flagged as spam.\n@required {id: [str] # Flags the comments with the given IDs as spam in the caller's opinion.}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/comments/setModerationStatus\n@desc Sets the moderation status of one or more comments.\n@required {id: [str] # Modifies the moderation status of the comments with the given IDs, moderationStatus: str(published/heldForReview/likelySpam/rejected) # Specifies the requested moderation status. Note, comments can be in statuses, which are not available through this call. For example, this call does not allow to mark a comment as 'likely spam'. Valid values: MODERATION_STATUS_PUBLISHED, MODERATION_STATUS_HELD_FOR_REVIEW, MODERATION_STATUS_REJECTED.}\n@optional {banAuthor: bool # If set to true the author of the comment gets added to the ban list. This means all future comments of the author will autmomatically be rejected. Only valid in combination with STATUS_REJECTED.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/i18nLanguages\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the i18nLanguage resource properties that the API response will include. Set the parameter value to snippet.}\n@optional {hl: str}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint GET /youtube/v3/i18nRegions\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the i18nRegion resource properties that the API response will include. Set the parameter value to snippet.}\n@optional {hl: str}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint DELETE /youtube/v3/liveBroadcasts\n@desc Delete a given broadcast.\n@required {id: str # Broadcast to delete.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/liveBroadcasts\n@desc Retrieve the list of broadcasts associated with the given channel.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, status and statistics.}\n@optional {broadcastStatus: str(broadcastStatusFilterUnspecified/all/active/upcoming/completed) # Return broadcasts with a certain status, e.g. active broadcasts., broadcastType: str(broadcastTypeFilterUnspecified/all/event/persistent) # Return only broadcasts with the selected type., id: [str] # Return broadcasts with the given ids from Stubby or Apiary., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool, onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/liveBroadcasts\n@desc Inserts a new stream for the authenticated user.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part properties that you can include in the parameter value are id, snippet, contentDetails, and status.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str} # Detailed settings of a broadcast., etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the broadcast., kind: str=youtube#liveBroadcast # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveBroadcast\"., snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map, title: str} # Basic broadcast information., statistics: map{concurrentViewers: str(uint64)} # Statistics about the live broadcast. These represent a snapshot of the values at the time of the request. Statistics are only returned for live broadcasts., status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool} # Live broadcast state.}\n@returns(200) {contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map{broadcastStreamDelayMs: int(uint32), embedHtml: str, enableMonitorStream: bool}, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str}, etag: str, id: str, kind: str, snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{concurrentViewers: str(uint64)}, status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool}} # Successful response\n\n@endpoint PUT /youtube/v3/liveBroadcasts\n@desc Updates an existing broadcast for the authenticated user.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part properties that you can include in the parameter value are id, snippet, contentDetails, and status. Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a broadcast's privacy status is defined in the status part. As such, if your request is updating a private or unlisted broadcast, and the request's part parameter value includes the status part, the broadcast's privacy setting will be updated to whatever value the request body specifies. If the request body does not specify a value, the existing privacy setting will be removed and the broadcast will revert to the default privacy setting.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str} # Detailed settings of a broadcast., etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the broadcast., kind: str=youtube#liveBroadcast # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveBroadcast\"., snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map, title: str} # Basic broadcast information., statistics: map{concurrentViewers: str(uint64)} # Statistics about the live broadcast. These represent a snapshot of the values at the time of the request. Statistics are only returned for live broadcasts., status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool} # Live broadcast state.}\n@returns(200) {contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map{broadcastStreamDelayMs: int(uint32), embedHtml: str, enableMonitorStream: bool}, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str}, etag: str, id: str, kind: str, snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{concurrentViewers: str(uint64)}, status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool}} # Successful response\n\n@endpoint POST /youtube/v3/liveBroadcasts/bind\n@desc Bind a broadcast to a stream.\n@required {id: str # Broadcast to bind to the stream, part: [str] # The *part* parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., streamId: str # Stream to bind, if not set unbind the current one.}\n@returns(200) {contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map{broadcastStreamDelayMs: int(uint32), embedHtml: str, enableMonitorStream: bool}, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str}, etag: str, id: str, kind: str, snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{concurrentViewers: str(uint64)}, status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool}} # Successful response\n\n@endpoint POST /youtube/v3/liveBroadcasts/cuepoint\n@desc Insert cuepoints in a broadcast\n@optional {id: str # Broadcast to insert ads to, or equivalently `external_video_id` for internal use., onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., part: [str] # The *part* parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status., cueType: str(cueTypeUnspecified/cueTypeAd), durationSecs: int(uint32) # The duration of this cuepoint., etag: str, id: str # The identifier for cuepoint resource., insertionOffsetTimeMs: str(int64) # The time when the cuepoint should be inserted by offset to the broadcast actual start time., walltimeMs: str(uint64) # The wall clock time at which the cuepoint should be inserted. Only one of insertion_offset_time_ms and walltime_ms may be set at a time.}\n@returns(200) {cueType: str, durationSecs: int(uint32), etag: str, id: str, insertionOffsetTimeMs: str(int64), walltimeMs: str(uint64)} # Successful response\n\n@endpoint POST /youtube/v3/liveBroadcasts/transition\n@desc Transition a broadcast to a given status.\n@required {broadcastStatus: str(statusUnspecified/testing/live/complete) # The status to which the broadcast is going to transition., id: str # Broadcast to transition., part: [str] # The *part* parameter specifies a comma-separated list of one or more liveBroadcast resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, contentDetails, and status.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.}\n@returns(200) {contentDetails: map{boundStreamId: str, boundStreamLastUpdateTimeMs: str(date-time), closedCaptionsType: str, enableAutoStart: bool, enableAutoStop: bool, enableClosedCaptions: bool, enableContentEncryption: bool, enableDvr: bool, enableEmbed: bool, enableLowLatency: bool, latencyPreference: str, mesh: str(byte), monitorStream: map{broadcastStreamDelayMs: int(uint32), embedHtml: str, enableMonitorStream: bool}, projection: str, recordFromStart: bool, startWithSlate: bool, stereoLayout: str}, etag: str, id: str, kind: str, snippet: map{actualEndTime: str(date-time), actualStartTime: str(date-time), channelId: str, description: str, isDefaultBroadcast: bool, liveChatId: str, publishedAt: str(date-time), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time), thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{concurrentViewers: str(uint64)}, status: map{lifeCycleStatus: str, liveBroadcastPriority: str, madeForKids: bool, privacyStatus: str, recordingStatus: str, selfDeclaredMadeForKids: bool}} # Successful response\n\n@endpoint DELETE /youtube/v3/liveChat/bans\n@desc Deletes a chat ban.\n@required {id: str}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/liveChat/bans\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response returns. Set the parameter value to snippet.}\n@optional {etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the ban., kind: str=youtube#liveChatBan # Identifies what kind of resource this is. Value: the fixed string `\"youtube#liveChatBan\"`., snippet: map{banDurationSeconds: str(uint64), bannedUserDetails: map, liveChatId: str, type: str}}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{banDurationSeconds: str(uint64), bannedUserDetails: map{channelId: str, channelUrl: str, displayName: str, profileImageUrl: str}, liveChatId: str, type: str}} # Successful response\n\n@endpoint DELETE /youtube/v3/liveChat/messages\n@desc Deletes a chat message.\n@required {id: str}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/liveChat/messages\n@desc Retrieves a list of resources, possibly filtered.\n@required {liveChatId: str # The id of the live chat for which comments should be returned., part: [str] # The *part* parameter specifies the liveChatComment resource parts that the API response will include. Supported values are id and snippet.}\n@optional {hl: str # Specifies the localization language in which the system messages should be returned., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., pageToken: str # The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken property identify other pages that could be retrieved., profileImageSize: int # Specifies the size of the profile image that should be returned for each user.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, offlineAt: str(date-time), pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, pollingIntervalMillis: int(uint32), tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/liveChat/messages\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes. It identifies the properties that the write operation will set as well as the properties that the API response will include. Set the parameter value to snippet.}\n@optional {authorDetails: map{channelId: str, channelUrl: str, displayName: str, isChatModerator: bool, isChatOwner: bool, isChatSponsor: bool, isVerified: bool, profileImageUrl: str}, etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the message., kind: str=youtube#liveChatMessage # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveChatMessage\"., snippet: map{authorChannelId: str, displayMessage: str, fanFundingEventDetails: map, giftMembershipReceivedDetails: map, hasDisplayContent: bool, liveChatId: str, memberMilestoneChatDetails: map, membershipGiftingDetails: map, messageDeletedDetails: map, messageRetractedDetails: map, newSponsorDetails: map, publishedAt: str(date-time), superChatDetails: map, superStickerDetails: map, textMessageDetails: map, type: str, userBannedDetails: map} # Next ID: 33}\n@returns(200) {authorDetails: map{channelId: str, channelUrl: str, displayName: str, isChatModerator: bool, isChatOwner: bool, isChatSponsor: bool, isVerified: bool, profileImageUrl: str}, etag: str, id: str, kind: str, snippet: map{authorChannelId: str, displayMessage: str, fanFundingEventDetails: map{amountDisplayString: str, amountMicros: str(uint64), currency: str, userComment: str}, giftMembershipReceivedDetails: map{associatedMembershipGiftingMessageId: str, gifterChannelId: str, memberLevelName: str}, hasDisplayContent: bool, liveChatId: str, memberMilestoneChatDetails: map{memberLevelName: str, memberMonth: int(uint32), userComment: str}, membershipGiftingDetails: map{giftMembershipsCount: int(int32), giftMembershipsLevelName: str}, messageDeletedDetails: map{deletedMessageId: str}, messageRetractedDetails: map{retractedMessageId: str}, newSponsorDetails: map{isUpgrade: bool, memberLevelName: str}, publishedAt: str(date-time), superChatDetails: map{amountDisplayString: str, amountMicros: str(uint64), currency: str, tier: int(uint32), userComment: str}, superStickerDetails: map{amountDisplayString: str, amountMicros: str(uint64), currency: str, superStickerMetadata: map{altText: str, altTextLanguage: str, stickerId: str}, tier: int(uint32)}, textMessageDetails: map{messageText: str}, type: str, userBannedDetails: map{banDurationSeconds: str(uint64), banType: str, bannedUserDetails: map{channelId: str, channelUrl: str, displayName: str, profileImageUrl: str}}}} # Successful response\n\n@endpoint DELETE /youtube/v3/liveChat/moderators\n@desc Deletes a chat moderator.\n@required {id: str}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/liveChat/moderators\n@desc Retrieves a list of resources, possibly filtered.\n@required {liveChatId: str # The id of the live chat for which moderators should be returned., part: [str] # The *part* parameter specifies the liveChatModerator resource parts that the API response will include. Supported values are id and snippet.}\n@optional {maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/liveChat/moderators\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response returns. Set the parameter value to snippet.}\n@optional {etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the moderator., kind: str=youtube#liveChatModerator # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveChatModerator\"., snippet: map{liveChatId: str, moderatorDetails: map}}\n@returns(200) {etag: str, id: str, kind: str, snippet: map{liveChatId: str, moderatorDetails: map{channelId: str, channelUrl: str, displayName: str, profileImageUrl: str}}} # Successful response\n\n@endpoint DELETE /youtube/v3/liveStreams\n@desc Deletes an existing stream for the authenticated user.\n@required {id: str}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/liveStreams\n@desc Retrieve the list of streams associated with the given channel. --\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more liveStream resource properties that the API response will include. The part names that you can include in the parameter value are id, snippet, cdn, and status.}\n@optional {id: [str] # Return LiveStreams with the given ids from Stubby or Apiary., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool, onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/liveStreams\n@desc Inserts a new stream for the authenticated user.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part properties that you can include in the parameter value are id, snippet, cdn, content_details, and status.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., cdn: map{format: str, frameRate: str, ingestionInfo: map, ingestionType: str, resolution: str} # Brief description of the live stream cdn settings., contentDetails: map{closedCaptionsIngestionUrl: str, isReusable: bool} # Detailed settings of a stream., etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the stream., kind: str=youtube#liveStream # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveStream\"., snippet: map{channelId: str, description: str, isDefaultStream: bool, publishedAt: str(date-time), title: str}, status: map{healthStatus: map, streamStatus: str} # Brief description of the live stream status.}\n@returns(200) {cdn: map{format: str, frameRate: str, ingestionInfo: map{backupIngestionAddress: str, ingestionAddress: str, rtmpsBackupIngestionAddress: str, rtmpsIngestionAddress: str, streamName: str}, ingestionType: str, resolution: str}, contentDetails: map{closedCaptionsIngestionUrl: str, isReusable: bool}, etag: str, id: str, kind: str, snippet: map{channelId: str, description: str, isDefaultStream: bool, publishedAt: str(date-time), title: str}, status: map{healthStatus: map{configurationIssues: [map], lastUpdateTimeSeconds: str(uint64), status: str}, streamStatus: str}} # Successful response\n\n@endpoint PUT /youtube/v3/liveStreams\n@desc Updates an existing stream for the authenticated user.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. The part properties that you can include in the parameter value are id, snippet, cdn, and status. Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. If the request body does not specify a value for a mutable property, the existing value for that property will be removed.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., cdn: map{format: str, frameRate: str, ingestionInfo: map, ingestionType: str, resolution: str} # Brief description of the live stream cdn settings., contentDetails: map{closedCaptionsIngestionUrl: str, isReusable: bool} # Detailed settings of a stream., etag: str # Etag of this resource., id: str # The ID that YouTube assigns to uniquely identify the stream., kind: str=youtube#liveStream # Identifies what kind of resource this is. Value: the fixed string \"youtube#liveStream\"., snippet: map{channelId: str, description: str, isDefaultStream: bool, publishedAt: str(date-time), title: str}, status: map{healthStatus: map, streamStatus: str} # Brief description of the live stream status.}\n@returns(200) {cdn: map{format: str, frameRate: str, ingestionInfo: map{backupIngestionAddress: str, ingestionAddress: str, rtmpsBackupIngestionAddress: str, rtmpsIngestionAddress: str, streamName: str}, ingestionType: str, resolution: str}, contentDetails: map{closedCaptionsIngestionUrl: str, isReusable: bool}, etag: str, id: str, kind: str, snippet: map{channelId: str, description: str, isDefaultStream: bool, publishedAt: str(date-time), title: str}, status: map{healthStatus: map{configurationIssues: [map], lastUpdateTimeSeconds: str(uint64), status: str}, streamStatus: str}} # Successful response\n\n@endpoint GET /youtube/v3/members\n@desc Retrieves a list of members that match the request criteria for a channel.\n@required {part: [str] # The *part* parameter specifies the member resource parts that the API response will include. Set the parameter value to snippet.}\n@optional {filterByMemberChannelId: str # Comma separated list of channel IDs. Only data about members that are part of this list will be included in the response., hasAccessToLevel: str # Filter members in the results set to the ones that have access to a level., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mode: str(listMembersModeUnknown/updates/all_current) # Parameter that specifies which channel members to return., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint GET /youtube/v3/membershipsLevels\n@desc Retrieves a list of all pricing levels offered by a creator to the fans.\n@required {part: [str] # The *part* parameter specifies the membershipsLevel resource parts that the API response will include. Supported values are id and snippet.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint DELETE /youtube/v3/playlistItems\n@desc Deletes a resource.\n@required {id: str}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/playlistItems\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more playlistItem resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlistItem resource, the snippet property contains numerous fields, including the title, description, position, and resourceId properties. As such, if you set *part=snippet*, the API response will contain all of those properties.}\n@optional {id: [str], maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., onBehalfOfContentOwner: str # *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., pageToken: str # 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., playlistId: str # Return the playlist items within the given playlist., videoId: str # Return the playlist items associated with the given video ID.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/playlistItems\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.}\n@optional {onBehalfOfContentOwner: str # *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., contentDetails: map{endAt: str, note: str, startAt: str, videoId: str, videoPublishedAt: str(date-time)}, etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the playlist item., kind: str=youtube#playlistItem # Identifies what kind of resource this is. Value: the fixed string \"youtube#playlistItem\"., snippet: map{channelId: str, channelTitle: str, description: str, playlistId: str, position: int(uint32), publishedAt: str(date-time), resourceId: map, thumbnails: map, title: str, videoOwnerChannelId: str, videoOwnerChannelTitle: str} # Basic details about a playlist, including title, description and thumbnails. Basic details of a YouTube Playlist item provided by the author. Next ID: 15, status: map{privacyStatus: str} # Information about the playlist item's privacy status.}\n@returns(200) {contentDetails: map{endAt: str, note: str, startAt: str, videoId: str, videoPublishedAt: str(date-time)}, etag: str, id: str, kind: str, snippet: map{channelId: str, channelTitle: str, description: str, playlistId: str, position: int(uint32), publishedAt: str(date-time), resourceId: map{channelId: str, kind: str, playlistId: str, videoId: str}, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str, videoOwnerChannelId: str, videoOwnerChannelTitle: str}, status: map{privacyStatus: str}} # Successful response\n\n@endpoint PUT /youtube/v3/playlistItems\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a playlist item can specify a start time and end time, which identify the times portion of the video that should play when users watch the video in the playlist. If your request is updating a playlist item that sets these values, and the request's part parameter value includes the contentDetails part, the playlist item's start and end times will be updated to whatever value the request body specifies. If the request body does not specify values, the existing start and end times will be removed and replaced with the default settings.}\n@optional {onBehalfOfContentOwner: str # *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., contentDetails: map{endAt: str, note: str, startAt: str, videoId: str, videoPublishedAt: str(date-time)}, etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the playlist item., kind: str=youtube#playlistItem # Identifies what kind of resource this is. Value: the fixed string \"youtube#playlistItem\"., snippet: map{channelId: str, channelTitle: str, description: str, playlistId: str, position: int(uint32), publishedAt: str(date-time), resourceId: map, thumbnails: map, title: str, videoOwnerChannelId: str, videoOwnerChannelTitle: str} # Basic details about a playlist, including title, description and thumbnails. Basic details of a YouTube Playlist item provided by the author. Next ID: 15, status: map{privacyStatus: str} # Information about the playlist item's privacy status.}\n@returns(200) {contentDetails: map{endAt: str, note: str, startAt: str, videoId: str, videoPublishedAt: str(date-time)}, etag: str, id: str, kind: str, snippet: map{channelId: str, channelTitle: str, description: str, playlistId: str, position: int(uint32), publishedAt: str(date-time), resourceId: map{channelId: str, kind: str, playlistId: str, videoId: str}, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str, videoOwnerChannelId: str, videoOwnerChannelTitle: str}, status: map{privacyStatus: str}} # Successful response\n\n@endpoint DELETE /youtube/v3/playlists\n@desc Deletes a resource.\n@required {id: str}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/playlists\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more playlist resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a playlist resource, the snippet property contains properties like author, title, description, tags, and timeCreated. As such, if you set *part=snippet*, the API response will contain all of those properties.}\n@optional {channelId: str # Return the playlists owned by the specified channel ID., hl: str # Return content in specified language, id: [str] # Return the playlists with the given IDs for Stubby or Apiary., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool # Return the playlists owned by the authenticated user., onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/playlists\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.}\n@optional {onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., contentDetails: map{itemCount: int(uint32)}, etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the playlist., kind: str=youtube#playlist # Identifies what kind of resource this is. Value: the fixed string \"youtube#playlist\"., localizations: map # Localizations for different languages, player: map{embedHtml: str}, snippet: map{channelId: str, channelTitle: str, defaultLanguage: str, description: str, localized: map, publishedAt: str(date-time), tags: [str], thumbnailVideoId: str, thumbnails: map, title: str} # Basic details about a playlist, including title, description and thumbnails., status: map{privacyStatus: str}}\n@returns(200) {contentDetails: map{itemCount: int(uint32)}, etag: str, id: str, kind: str, localizations: map, player: map{embedHtml: str}, snippet: map{channelId: str, channelTitle: str, defaultLanguage: str, description: str, localized: map{description: str, title: str}, publishedAt: str(date-time), tags: [str], thumbnailVideoId: str, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, status: map{privacyStatus: str}} # Successful response\n\n@endpoint PUT /youtube/v3/playlists\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. Note that this method will override the existing values for mutable properties that are contained in any parts that the request body specifies. For example, a playlist's description is contained in the snippet part, which must be included in the request body. If the request does not specify a value for the snippet.description property, the playlist's existing description will be deleted.}\n@optional {onBehalfOfContentOwner: str # *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., contentDetails: map{itemCount: int(uint32)}, etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the playlist., kind: str=youtube#playlist # Identifies what kind of resource this is. Value: the fixed string \"youtube#playlist\"., localizations: map # Localizations for different languages, player: map{embedHtml: str}, snippet: map{channelId: str, channelTitle: str, defaultLanguage: str, description: str, localized: map, publishedAt: str(date-time), tags: [str], thumbnailVideoId: str, thumbnails: map, title: str} # Basic details about a playlist, including title, description and thumbnails., status: map{privacyStatus: str}}\n@returns(200) {contentDetails: map{itemCount: int(uint32)}, etag: str, id: str, kind: str, localizations: map, player: map{embedHtml: str}, snippet: map{channelId: str, channelTitle: str, defaultLanguage: str, description: str, localized: map{description: str, title: str}, publishedAt: str(date-time), tags: [str], thumbnailVideoId: str, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, status: map{privacyStatus: str}} # Successful response\n\n@endpoint GET /youtube/v3/search\n@desc Retrieves a list of search resources\n@required {part: [str] # 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.}\n@optional {channelId: str # Filter on resources belonging to this channelId., channelType: str(channelTypeUnspecified/any/show) # Add a filter on the channel search., eventType: str(none/upcoming/live/completed) # Filter on the livestream status of the videos., forContentOwner: bool # Search owned by a content owner., forDeveloper: bool # Restrict the search to only retrieve videos uploaded using the project id of the authenticated user., forMine: bool # Search for the private videos of the authenticated user., location: str # Filter on location of the video, locationRadius: str # Filter on distance from the location (specified above)., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., onBehalfOfContentOwner: str # *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., order: str(searchSortUnspecified/date/rating/viewCount/relevance/title/videoCount) # Sort order of the results., pageToken: str # 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., publishedAfter: str # Filter on resources published after this date., publishedBefore: str # Filter on resources published before this date., q: str # Textual search terms to match., regionCode: str # Display the content as seen by viewers in this country., relatedToVideoId: str # Search related to a resource., relevanceLanguage: str # Return results relevant to this language., safeSearch: str(safeSearchSettingUnspecified/none/moderate/strict) # Indicates whether the search results should include restricted content as well as standard content., topicId: str # Restrict results to a particular topic., type: [str] # Restrict results to a particular set of resource types from One Platform., videoCaption: str(videoCaptionUnspecified/any/closedCaption/none) # Filter on the presence of captions on the videos., videoCategoryId: str # Filter on videos in a specific category., videoDefinition: str(any/standard/high) # Filter on the definition of the videos., videoDimension: str(any/2d/3d) # Filter on 3d videos., videoDuration: str(videoDurationUnspecified/any/short/medium/long) # Filter on the duration of the videos., videoEmbeddable: str(videoEmbeddableUnspecified/any/true) # Filter on embeddable videos., videoLicense: str(any/youtube/creativeCommon) # Filter on the license of the videos., videoSyndicated: str(videoSyndicatedUnspecified/any/true) # Filter on syndicated videos., videoType: str(videoTypeUnspecified/any/movie/episode) # Filter on videos of a specific type.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, regionCode: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint DELETE /youtube/v3/subscriptions\n@desc Deletes a resource.\n@required {id: str}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/subscriptions\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more subscription resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a subscription resource, the snippet property contains other properties, such as a display title for the subscription. If you set *part=snippet*, the API response will also contain all of those nested properties.}\n@optional {channelId: str # Return the subscriptions of the given channel owner., forChannelId: str # Return the subscriptions to the subset of these channels that the authenticated user is subscribed to., id: [str] # Return the subscriptions with the given IDs for Stubby or Apiary., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., mine: bool # Flag for returning the subscriptions of the authenticated user., myRecentSubscribers: bool, mySubscribers: bool # Return the subscribers of the given channel owner., onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., order: str(subscriptionOrderUnspecified/relevance/unread/alphabetical) # The order of the returned subscriptions, pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/subscriptions\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.}\n@optional {contentDetails: map{activityType: str, newItemCount: int(uint32), totalItemCount: int(uint32)} # Details about the content to witch a subscription refers., etag: str # Etag of this resource., id: str # The ID that YouTube uses to uniquely identify the subscription., kind: str=youtube#subscription # Identifies what kind of resource this is. Value: the fixed string \"youtube#subscription\"., snippet: map{channelId: str, channelTitle: str, description: str, publishedAt: str(date-time), resourceId: map, thumbnails: map, title: str} # Basic details about a subscription, including title, description and thumbnails of the subscribed item., subscriberSnippet: map{channelId: str, description: str, thumbnails: map, title: str} # Basic details about a subscription's subscriber including title, description, channel ID and thumbnails.}\n@returns(200) {contentDetails: map{activityType: str, newItemCount: int(uint32), totalItemCount: int(uint32)}, etag: str, id: str, kind: str, snippet: map{channelId: str, channelTitle: str, description: str, publishedAt: str(date-time), resourceId: map{channelId: str, kind: str, playlistId: str, videoId: str}, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, subscriberSnippet: map{channelId: str, description: str, thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}} # Successful response\n\n@endpoint GET /youtube/v3/superChatEvents\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the superChatEvent resource parts that the API response will include. This parameter is currently not supported.}\n@optional {hl: str # Return rendered funding amounts in specified language., maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set., pageToken: str # 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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/tests\n@desc POST method.\n@required {part: [str]}\n@optional {externalChannelId: str, featuredPart: bool, gaia: str(int64), id: str, snippet: map{}}\n@returns(200) {featuredPart: bool, gaia: str(int64), id: str, snippet: map} # Successful response\n\n@endpoint DELETE /youtube/v3/thirdPartyLinks\n@desc Deletes a resource.\n@required {linkingToken: str # Delete the partner links with the given linking token., type: str(linkUnspecified/channelToStoreLink) # Type of the link to be deleted.}\n@optional {externalChannelId: str # Channel ID to which changes should be applied, for delegation., part: [str] # Do not use. Required for compatibility.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/thirdPartyLinks\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the thirdPartyLink resource parts that the API response will include. Supported values are linkingToken, status, and snippet.}\n@optional {externalChannelId: str # Channel ID to which changes should be applied, for delegation., linkingToken: str # Get a third party link with the given linking token., type: str(linkUnspecified/channelToStoreLink) # Get a third party link of the given type.}\n@returns(200) {etag: str, items: [map], kind: str} # Successful response\n\n@endpoint POST /youtube/v3/thirdPartyLinks\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter specifies the thirdPartyLink resource parts that the API request and response will include. Supported values are linkingToken, status, and snippet.}\n@optional {externalChannelId: str # Channel ID to which changes should be applied, for delegation., etag: str # Etag of this resource, kind: str=youtube#thirdPartyLink # Identifies what kind of resource this is. Value: the fixed string \"youtube#thirdPartyLink\"., linkingToken: str # The linking_token identifies a YouTube account and channel with which the third party account is linked., snippet: map{channelToStoreLink: map, type: str} # Basic information about a third party account link, including its type and type-specific information., status: map{linkStatus: str} # The third-party link status object contains information about the status of the link.}\n@returns(200) {etag: str, kind: str, linkingToken: str, snippet: map{channelToStoreLink: map{merchantId: str(uint64), storeName: str, storeUrl: str}, type: str}, status: map{linkStatus: str}} # Successful response\n\n@endpoint PUT /youtube/v3/thirdPartyLinks\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter specifies the thirdPartyLink resource parts that the API request and response will include. Supported values are linkingToken, status, and snippet.}\n@optional {externalChannelId: str # Channel ID to which changes should be applied, for delegation., etag: str # Etag of this resource, kind: str=youtube#thirdPartyLink # Identifies what kind of resource this is. Value: the fixed string \"youtube#thirdPartyLink\"., linkingToken: str # The linking_token identifies a YouTube account and channel with which the third party account is linked., snippet: map{channelToStoreLink: map, type: str} # Basic information about a third party account link, including its type and type-specific information., status: map{linkStatus: str} # The third-party link status object contains information about the status of the link.}\n@returns(200) {etag: str, kind: str, linkingToken: str, snippet: map{channelToStoreLink: map{merchantId: str(uint64), storeName: str, storeUrl: str}, type: str}, status: map{linkStatus: str}} # Successful response\n\n@endpoint POST /youtube/v3/thumbnails/set\n@desc As this is not an insert in a strict sense (it supports uploading/setting of a thumbnail for multiple videos, which doesn't result in creation of a single resource), I use a custom verb here.\n@required {videoId: str # Returns the Thumbnail with the given video IDs for Stubby or Apiary.}\n@optional {onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint GET /youtube/v3/videoAbuseReportReasons\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the videoCategory resource parts that the API response will include. Supported values are id and snippet.}\n@optional {hl: str}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint GET /youtube/v3/videoCategories\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies the videoCategory resource properties that the API response will include. Set the parameter value to snippet.}\n@optional {hl: str, id: [str] # Returns the video categories with the given IDs for Stubby or Apiary., regionCode: str}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint DELETE /youtube/v3/videos\n@desc Deletes a resource.\n@required {id: str}\n@optional {onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner.}\n@returns(200) Successful response\n\n@endpoint GET /youtube/v3/videos\n@desc Retrieves a list of resources, possibly filtered.\n@required {part: [str] # The *part* parameter specifies a comma-separated list of one or more video resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response. For example, in a video resource, the snippet property contains the channelId, title, description, tags, and categoryId properties. As such, if you set *part=snippet*, the API response will contain all of those properties.}\n@optional {chart: str(chartUnspecified/mostPopular) # Return the videos that are in the specified chart., hl: str # Stands for \"host language\". Specifies the localization language of the metadata to be filled into snippet.localized. The field is filled with the default metadata if there is no localization in the specified language. The parameter value must be a language code included in the list returned by the i18nLanguages.list method (e.g. en_US, es_MX)., id: [str] # Return videos with the given ids., locale: str, maxHeight: int, maxResults: int # The *maxResults* parameter specifies the maximum number of items that should be returned in the result set. *Note:* This parameter is supported for use in conjunction with the myRating and chart parameters, but it is not supported for use in conjunction with the id parameter., maxWidth: int # Return the player with maximum height specified in, myRating: str(none/like/dislike) # Return videos liked/disliked by the authenticated user. Does not support RateType.RATED_TYPE_NONE., onBehalfOfContentOwner: str # *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., pageToken: str # 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. *Note:* This parameter is supported for use in conjunction with the myRating and chart parameters, but it is not supported for use in conjunction with the id parameter., regionCode: str # Use a chart that is specific to the specified region, videoCategoryId: str # Use chart that is specific to the specified video category}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, nextPageToken: str, pageInfo: map{resultsPerPage: int(int32), totalResults: int(int32)}, prevPageToken: str, tokenPagination: map, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/videos\n@desc Inserts a new resource into this collection.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. Note that not all parts contain properties that can be set when inserting or updating a video. For example, the statistics object encapsulates statistics that YouTube calculates for a video and does not contain values that you can set or modify. If the parameter value specifies a part that does not contain mutable values, that part will still be included in the API response.}\n@optional {autoLevels: bool # Should auto-levels be applied to the upload., notifySubscribers: bool # Notify the channel subscribers about the new video. As default, the notification is enabled., onBehalfOfContentOwner: str # *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., onBehalfOfContentOwnerChannel: str # This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel., stabilize: bool # Should stabilize be applied to the upload.}\n@returns(200) {ageGating: map{alcoholContent: bool, restricted: bool, videoGameRating: str}, contentDetails: map{caption: str, contentRating: map{acbRating: str, agcomRating: str, anatelRating: str, bbfcRating: str, bfvcRating: str, bmukkRating: str, catvRating: str, catvfrRating: str, cbfcRating: str, cccRating: str, cceRating: str, chfilmRating: str, chvrsRating: str, cicfRating: str, cnaRating: str, cncRating: str, csaRating: str, cscfRating: str, czfilmRating: str, djctqRating: str, djctqRatingReasons: [str], ecbmctRating: str, eefilmRating: str, egfilmRating: str, eirinRating: str, fcbmRating: str, fcoRating: str, fmocRating: str, fpbRating: str, fpbRatingReasons: [str], fskRating: str, grfilmRating: str, icaaRating: str, ifcoRating: str, ilfilmRating: str, incaaRating: str, kfcbRating: str, kijkwijzerRating: str, kmrbRating: str, lsfRating: str, mccaaRating: str, mccypRating: str, mcstRating: str, mdaRating: str, medietilsynetRating: str, mekuRating: str, menaMpaaRating: str, mibacRating: str, mocRating: str, moctwRating: str, mpaaRating: str, mpaatRating: str, mtrcbRating: str, nbcRating: str, nbcplRating: str, nfrcRating: str, nfvcbRating: str, nkclvRating: str, nmcRating: str, oflcRating: str, pefilmRating: str, rcnofRating: str, resorteviolenciaRating: str, rtcRating: str, rteRating: str, russiaRating: str, skfilmRating: str, smaisRating: str, smsaRating: str, tvpgRating: str, ytRating: str}, countryRestriction: map{allowed: bool, exception: [str]}, definition: str, dimension: str, duration: str, hasCustomThumbnail: bool, licensedContent: bool, projection: str, regionRestriction: map{allowed: [str], blocked: [str]}}, etag: str, fileDetails: map{audioStreams: [map], bitrateBps: str(uint64), container: str, creationTime: str, durationMs: str(uint64), fileName: str, fileSize: str(uint64), fileType: str, videoStreams: [map]}, id: str, kind: str, liveStreamingDetails: map{activeLiveChatId: str, actualEndTime: str(date-time), actualStartTime: str(date-time), concurrentViewers: str(uint64), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time)}, localizations: map, monetizationDetails: map{access: map{allowed: bool, exception: [str]}}, player: map{embedHeight: str(int64), embedHtml: str, embedWidth: str(int64)}, processingDetails: map{editorSuggestionsAvailability: str, fileDetailsAvailability: str, processingFailureReason: str, processingIssuesAvailability: str, processingProgress: map{partsProcessed: str(uint64), partsTotal: str(uint64), timeLeftMs: str(uint64)}, processingStatus: str, tagSuggestionsAvailability: str, thumbnailsAvailability: str}, projectDetails: map, recordingDetails: map{location: map{altitude: num(double), latitude: num(double), longitude: num(double)}, locationDescription: str, recordingDate: str(date-time)}, snippet: map{categoryId: str, channelId: str, channelTitle: str, defaultAudioLanguage: str, defaultLanguage: str, description: str, liveBroadcastContent: str, localized: map{description: str, title: str}, publishedAt: str(date-time), tags: [str], thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{commentCount: str(uint64), dislikeCount: str(uint64), favoriteCount: str(uint64), likeCount: str(uint64), viewCount: str(uint64)}, status: map{embeddable: bool, failureReason: str, license: str, madeForKids: bool, privacyStatus: str, publicStatsViewable: bool, publishAt: str(date-time), rejectionReason: str, selfDeclaredMadeForKids: bool, uploadStatus: str}, suggestions: map{editorSuggestions: [str], processingErrors: [str], processingHints: [str], processingWarnings: [str], tagSuggestions: [map]}, topicDetails: map{relevantTopicIds: [str], topicCategories: [str], topicIds: [str]}} # Successful response\n\n@endpoint PUT /youtube/v3/videos\n@desc Updates an existing resource.\n@required {part: [str] # The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include. Note that this method will override the existing values for all of the mutable properties that are contained in any parts that the parameter value specifies. For example, a video's privacy setting is contained in the status part. As such, if your request is updating a private video, and the request's part parameter value includes the status part, the video's privacy setting will be updated to whatever value the request body specifies. If the request body does not specify a value, the existing privacy setting will be removed and the video will revert to the default privacy setting. In addition, not all parts contain properties that can be set when inserting or updating a video. For example, the statistics object encapsulates statistics that YouTube calculates for a video and does not contain values that you can set or modify. If the parameter value specifies a part that does not contain mutable values, that part will still be included in the API response.}\n@optional {onBehalfOfContentOwner: str # *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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner., ageGating: map{alcoholContent: bool, restricted: bool, videoGameRating: str}, contentDetails: map{caption: str, contentRating: map, countryRestriction: map, definition: str, dimension: str, duration: str, hasCustomThumbnail: bool, licensedContent: bool, projection: str, regionRestriction: map} # Details about the content of a YouTube Video., etag: str # Etag of this resource., fileDetails: map{audioStreams: [map], bitrateBps: str(uint64), container: str, creationTime: str, durationMs: str(uint64), fileName: str, fileSize: str(uint64), fileType: str, videoStreams: [map]} # Describes original video file properties, including technical details about audio and video streams, but also metadata information like content length, digitization time, or geotagging information., id: str # The ID that YouTube uses to uniquely identify the video., kind: str=youtube#video # Identifies what kind of resource this is. Value: the fixed string \"youtube#video\"., liveStreamingDetails: map{activeLiveChatId: str, actualEndTime: str(date-time), actualStartTime: str(date-time), concurrentViewers: str(uint64), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time)} # Details about the live streaming metadata., localizations: map # The localizations object contains localized versions of the basic details about the video, such as its title and description., monetizationDetails: map{access: map} # Details about monetization of a YouTube Video., player: map{embedHeight: str(int64), embedHtml: str, embedWidth: str(int64)} # Player to be used for a video playback., processingDetails: map{editorSuggestionsAvailability: str, fileDetailsAvailability: str, processingFailureReason: str, processingIssuesAvailability: str, processingProgress: map, processingStatus: str, tagSuggestionsAvailability: str, thumbnailsAvailability: str} # Describes processing status and progress and availability of some other Video resource parts., projectDetails: map{} # DEPRECATED. b/157517979: This part was never populated after it was added. However, it sees non-zero traffic because there is generated client code in the wild that refers to it [1]. We keep this field and do NOT remove it because otherwise V3 would return an error when this part gets requested [2]. [1] https://developers.google.com/resources/api-libraries/documentation/youtube/v3/csharp/latest/classGoogle_1_1Apis_1_1YouTube_1_1v3_1_1Data_1_1VideoProjectDetails.html [2] http://google3/video/youtube/src/python/servers/data_api/common.py?l=1565-1569&rcl=344141677, recordingDetails: map{location: map, locationDescription: str, recordingDate: str(date-time)} # Recording information associated with the video., snippet: map{categoryId: str, channelId: str, channelTitle: str, defaultAudioLanguage: str, defaultLanguage: str, description: str, liveBroadcastContent: str, localized: map, publishedAt: str(date-time), tags: [str], thumbnails: map, title: str} # Basic details about a video, including title, description, uploader, thumbnails and category., statistics: map{commentCount: str(uint64), dislikeCount: str(uint64), favoriteCount: str(uint64), likeCount: str(uint64), viewCount: str(uint64)} # Statistics about the video, such as the number of times the video was viewed or liked., status: map{embeddable: bool, failureReason: str, license: str, madeForKids: bool, privacyStatus: str, publicStatsViewable: bool, publishAt: str(date-time), rejectionReason: str, selfDeclaredMadeForKids: bool, uploadStatus: str} # Basic details about a video category, such as its localized title. Next Id: 18, suggestions: map{editorSuggestions: [str], processingErrors: [str], processingHints: [str], processingWarnings: [str], tagSuggestions: [map]} # Specifies suggestions on how to improve video content, including encoding hints, tag suggestions, and editor suggestions., topicDetails: map{relevantTopicIds: [str], topicCategories: [str], topicIds: [str]} # Freebase topic information related to the video.}\n@returns(200) {ageGating: map{alcoholContent: bool, restricted: bool, videoGameRating: str}, contentDetails: map{caption: str, contentRating: map{acbRating: str, agcomRating: str, anatelRating: str, bbfcRating: str, bfvcRating: str, bmukkRating: str, catvRating: str, catvfrRating: str, cbfcRating: str, cccRating: str, cceRating: str, chfilmRating: str, chvrsRating: str, cicfRating: str, cnaRating: str, cncRating: str, csaRating: str, cscfRating: str, czfilmRating: str, djctqRating: str, djctqRatingReasons: [str], ecbmctRating: str, eefilmRating: str, egfilmRating: str, eirinRating: str, fcbmRating: str, fcoRating: str, fmocRating: str, fpbRating: str, fpbRatingReasons: [str], fskRating: str, grfilmRating: str, icaaRating: str, ifcoRating: str, ilfilmRating: str, incaaRating: str, kfcbRating: str, kijkwijzerRating: str, kmrbRating: str, lsfRating: str, mccaaRating: str, mccypRating: str, mcstRating: str, mdaRating: str, medietilsynetRating: str, mekuRating: str, menaMpaaRating: str, mibacRating: str, mocRating: str, moctwRating: str, mpaaRating: str, mpaatRating: str, mtrcbRating: str, nbcRating: str, nbcplRating: str, nfrcRating: str, nfvcbRating: str, nkclvRating: str, nmcRating: str, oflcRating: str, pefilmRating: str, rcnofRating: str, resorteviolenciaRating: str, rtcRating: str, rteRating: str, russiaRating: str, skfilmRating: str, smaisRating: str, smsaRating: str, tvpgRating: str, ytRating: str}, countryRestriction: map{allowed: bool, exception: [str]}, definition: str, dimension: str, duration: str, hasCustomThumbnail: bool, licensedContent: bool, projection: str, regionRestriction: map{allowed: [str], blocked: [str]}}, etag: str, fileDetails: map{audioStreams: [map], bitrateBps: str(uint64), container: str, creationTime: str, durationMs: str(uint64), fileName: str, fileSize: str(uint64), fileType: str, videoStreams: [map]}, id: str, kind: str, liveStreamingDetails: map{activeLiveChatId: str, actualEndTime: str(date-time), actualStartTime: str(date-time), concurrentViewers: str(uint64), scheduledEndTime: str(date-time), scheduledStartTime: str(date-time)}, localizations: map, monetizationDetails: map{access: map{allowed: bool, exception: [str]}}, player: map{embedHeight: str(int64), embedHtml: str, embedWidth: str(int64)}, processingDetails: map{editorSuggestionsAvailability: str, fileDetailsAvailability: str, processingFailureReason: str, processingIssuesAvailability: str, processingProgress: map{partsProcessed: str(uint64), partsTotal: str(uint64), timeLeftMs: str(uint64)}, processingStatus: str, tagSuggestionsAvailability: str, thumbnailsAvailability: str}, projectDetails: map, recordingDetails: map{location: map{altitude: num(double), latitude: num(double), longitude: num(double)}, locationDescription: str, recordingDate: str(date-time)}, snippet: map{categoryId: str, channelId: str, channelTitle: str, defaultAudioLanguage: str, defaultLanguage: str, description: str, liveBroadcastContent: str, localized: map{description: str, title: str}, publishedAt: str(date-time), tags: [str], thumbnails: map{high: map{height: int(uint32), url: str, width: int(uint32)}, maxres: map{height: int(uint32), url: str, width: int(uint32)}, medium: map{height: int(uint32), url: str, width: int(uint32)}, standard: map{height: int(uint32), url: str, width: int(uint32)}}, title: str}, statistics: map{commentCount: str(uint64), dislikeCount: str(uint64), favoriteCount: str(uint64), likeCount: str(uint64), viewCount: str(uint64)}, status: map{embeddable: bool, failureReason: str, license: str, madeForKids: bool, privacyStatus: str, publicStatsViewable: bool, publishAt: str(date-time), rejectionReason: str, selfDeclaredMadeForKids: bool, uploadStatus: str}, suggestions: map{editorSuggestions: [str], processingErrors: [str], processingHints: [str], processingWarnings: [str], tagSuggestions: [map]}, topicDetails: map{relevantTopicIds: [str], topicCategories: [str], topicIds: [str]}} # Successful response\n\n@endpoint GET /youtube/v3/videos/getRating\n@desc Retrieves the ratings that the authorized user gave to a list of specified videos.\n@required {id: [str]}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) {etag: str, eventId: str, items: [map], kind: str, visitorId: str} # Successful response\n\n@endpoint POST /youtube/v3/videos/rate\n@desc Adds a like or dislike rating to a video or removes a rating from a video.\n@required {id: str, rating: str(none/like/dislike)}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/videos/reportAbuse\n@desc Report abuse for a video.\n@optional {onBehalfOfContentOwner: str # *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., comments: str # Additional comments regarding the abuse report., language: str # The language that the content was viewed in., reasonId: str # The high-level, or primary, reason that the content is abusive. The value is an abuse report reason ID., secondaryReasonId: str # The specific, or secondary, reason that this content is abusive (if available). The value is an abuse report reason ID that is a valid secondary reason for the primary reason., videoId: str # The ID that YouTube uses to uniquely identify the video.}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/watermarks/set\n@desc Allows upload of watermark image and setting it for a channel.\n@required {channelId: str}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) Successful response\n\n@endpoint POST /youtube/v3/watermarks/unset\n@desc Allows removal of channel watermark.\n@required {channelId: str}\n@optional {onBehalfOfContentOwner: str # *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.}\n@returns(200) Successful response\n\n@end\n"}}