Documentation

Overview

Package youtube provides access to the YouTube Data API.

For product documentation, see: https://developers.google.com/youtube/v3

Creating a client

Usage example:

import "google.golang.org/api/youtube/v3"
...
ctx := context.Background()
youtubeService, err := youtube.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:

youtubeService, err := youtube.NewService(ctx, option.WithScopes(youtube.YoutubepartnerChannelAuditScope))

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:

youtubeService, err := youtube.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
youtubeService, err := youtube.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Constants

View Source
const (
	// Manage your YouTube account
	YoutubeScope = "https://www.googleapis.com/auth/youtube"

	// See a list of your current active channel members, their current
	// level, and when they became a member
	YoutubeChannelMembershipsCreatorScope = "https://www.googleapis.com/auth/youtube.channel-memberships.creator"

	// See, edit, and permanently delete your YouTube videos, ratings,
	// comments and captions
	YoutubeForceSslScope = "https://www.googleapis.com/auth/youtube.force-ssl"

	// View your YouTube account
	YoutubeReadonlyScope = "https://www.googleapis.com/auth/youtube.readonly"

	// Manage your YouTube videos
	YoutubeUploadScope = "https://www.googleapis.com/auth/youtube.upload"

	// View and manage your assets and associated content on YouTube
	YoutubepartnerScope = "https://www.googleapis.com/auth/youtubepartner"

	// View private information of your YouTube channel relevant during the
	// audit process with a YouTube partner
	YoutubepartnerChannelAuditScope = "https://www.googleapis.com/auth/youtubepartner-channel-audit"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AccessPolicy

    type AccessPolicy struct {
    	// Allowed: The value of allowed indicates whether the access to the
    	// policy is allowed or denied by default.
    	Allowed bool `json:"allowed,omitempty"`
    
    	// Exception: A list of region codes that identify countries where the
    	// default policy do not apply.
    	Exception []string `json:"exception,omitempty"`
    
    	// ForceSendFields is a list of field names (e.g. "Allowed") to
    	// unconditionally include in API requests. By default, fields with
    	// empty values are omitted from API requests. However, any non-pointer,
    	// non-interface field appearing in ForceSendFields will be sent to the
    	// server regardless of whether the field is empty or not. This may be
    	// used to include empty fields in Patch requests.
    	ForceSendFields []string `json:"-"`
    
    	// NullFields is a list of field names (e.g. "Allowed") to include in
    	// API requests with the JSON null value. By default, fields with empty
    	// values are omitted from API requests. However, any field with an
    	// empty value appearing in NullFields will be sent to the server as
    	// null. It is an error if a field in this list has a non-empty value.
    	// This may be used to include null fields in Patch requests.
    	NullFields []string `json:"-"`
    }

      AccessPolicy: Rights management policy for YouTube resources.

      func (*AccessPolicy) MarshalJSON

      func (s *AccessPolicy) MarshalJSON() ([]byte, error)

      type ActivitiesInsertCall

      type ActivitiesInsertCall struct {
      	// contains filtered or unexported fields
      }

      func (*ActivitiesInsertCall) Context

        Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

        func (*ActivitiesInsertCall) Do

          Do executes the "youtube.activities.insert" call. Exactly one of *Activity or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Activity.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

          func (*ActivitiesInsertCall) Fields

            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

            func (*ActivitiesInsertCall) Header

            func (c *ActivitiesInsertCall) Header() http.Header

              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

              type ActivitiesListCall

              type ActivitiesListCall struct {
              	// contains filtered or unexported fields
              }

              func (*ActivitiesListCall) ChannelId

              func (c *ActivitiesListCall) ChannelId(channelId string) *ActivitiesListCall

                ChannelId sets the optional parameter "channelId": The channelId parameter specifies a unique YouTube channel ID. The API will then return a list of that channel's activities.

                func (*ActivitiesListCall) Context

                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                  func (*ActivitiesListCall) Do

                    Do executes the "youtube.activities.list" call. Exactly one of *ActivityListResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ActivityListResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                    func (*ActivitiesListCall) Fields

                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                      func (*ActivitiesListCall) Header

                      func (c *ActivitiesListCall) Header() http.Header

                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                        func (*ActivitiesListCall) Home

                          Home sets the optional parameter "home": Set this parameter's value to true to retrieve the activity feed that displays on the YouTube home page for the currently authenticated user.

                          func (*ActivitiesListCall) IfNoneMatch

                          func (c *ActivitiesListCall) IfNoneMatch(entityTag string) *ActivitiesListCall

                            IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                            func (*ActivitiesListCall) MaxResults

                            func (c *ActivitiesListCall) MaxResults(maxResults int64) *ActivitiesListCall

                              MaxResults sets the optional parameter "maxResults": The maxResults parameter specifies the maximum number of items that should be returned in the result set.

                              func (*ActivitiesListCall) Mine

                                Mine sets the optional parameter "mine": Set this parameter's value to true to retrieve a feed of the authenticated user's activities.

                                func (*ActivitiesListCall) PageToken

                                func (c *ActivitiesListCall) PageToken(pageToken string) *ActivitiesListCall

                                  PageToken sets the optional parameter "pageToken": 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.

                                  func (*ActivitiesListCall) Pages

                                    Pages invokes f for each page of results. A non-nil error returned from f will halt the iteration. The provided context supersedes any context provided to the Context method.

                                    func (*ActivitiesListCall) PublishedAfter

                                    func (c *ActivitiesListCall) PublishedAfter(publishedAfter string) *ActivitiesListCall

                                      PublishedAfter sets the optional parameter "publishedAfter": The publishedAfter parameter specifies the earliest date and time that an activity could have occurred for that activity to be included in the API response. If the parameter value specifies a day, but not a time, then any activities that occurred that day will be included in the result set. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format.

                                      func (*ActivitiesListCall) PublishedBefore

                                      func (c *ActivitiesListCall) PublishedBefore(publishedBefore string) *ActivitiesListCall

                                        PublishedBefore sets the optional parameter "publishedBefore": The publishedBefore parameter specifies the date and time before which an activity must have occurred for that activity to be included in the API response. If the parameter value specifies a day, but not a time, then any activities that occurred that day will be excluded from the result set. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format.

                                        func (*ActivitiesListCall) RegionCode

                                        func (c *ActivitiesListCall) RegionCode(regionCode string) *ActivitiesListCall

                                          RegionCode sets the optional parameter "regionCode": The regionCode parameter instructs the API to return results for the specified country. The parameter value is an ISO 3166-1 alpha-2 country code. YouTube uses this value when the authorized user's previous activity on YouTube does not provide enough information to generate the activity feed.

                                          type ActivitiesService

                                          type ActivitiesService struct {
                                          	// contains filtered or unexported fields
                                          }

                                          func NewActivitiesService

                                          func NewActivitiesService(s *Service) *ActivitiesService

                                          func (*ActivitiesService) Insert

                                          func (r *ActivitiesService) Insert(part string, activity *Activity) *ActivitiesInsertCall

                                            Insert: Posts a bulletin for a specific channel. (The user submitting the request must be authorized to act on the channel's behalf.)

                                            Note: Even though an activity resource can contain information about actions like a user rating a video or marking a video as a favorite, you need to use other API methods to generate those activity resources. For example, you would use the API's videos.rate() method to rate a video and the playlistItems.insert() method to mark a video as a favorite.

                                            func (*ActivitiesService) List

                                              List: Returns a list of channel activity events that match the request criteria. For example, you can retrieve events associated with a particular channel, events associated with the user's subscriptions and Google+ friends, or the YouTube home page feed, which is customized for each user.

                                              type Activity

                                              type Activity struct {
                                              	// ContentDetails: The contentDetails object contains information about
                                              	// the content associated with the activity. For example, if the
                                              	// snippet.type value is videoRated, then the contentDetails object's
                                              	// content identifies the rated video.
                                              	ContentDetails *ActivityContentDetails `json:"contentDetails,omitempty"`
                                              
                                              	// Etag: Etag of this resource.
                                              	Etag string `json:"etag,omitempty"`
                                              
                                              	// Id: The ID that YouTube uses to uniquely identify the activity.
                                              	Id string `json:"id,omitempty"`
                                              
                                              	// Kind: Identifies what kind of resource this is. Value: the fixed
                                              	// string "youtube#activity".
                                              	Kind string `json:"kind,omitempty"`
                                              
                                              	// Snippet: The snippet object contains basic details about the
                                              	// activity, including the activity's type and group ID.
                                              	Snippet *ActivitySnippet `json:"snippet,omitempty"`
                                              
                                              	// ServerResponse contains the HTTP response code and headers from the
                                              	// server.
                                              	googleapi.ServerResponse `json:"-"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "ContentDetails") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "ContentDetails") to
                                              	// include in API requests with the JSON null value. By default, fields
                                              	// with empty values are omitted from API requests. However, any field
                                              	// with an empty value appearing in NullFields will be sent to the
                                              	// server as null. It is an error if a field in this list has a
                                              	// non-empty value. This may be used to include null fields in Patch
                                              	// requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                Activity: An activity resource contains information about an action that a particular channel, or user, has taken on YouTube.The actions reported in activity feeds include rating a video, sharing a video, marking a video as a favorite, commenting on a video, uploading a video, and so forth. Each activity resource identifies the type of action, the channel associated with the action, and the resource(s) associated with the action, such as the video that was rated or uploaded.

                                                func (*Activity) MarshalJSON

                                                func (s *Activity) MarshalJSON() ([]byte, error)

                                                type ActivityContentDetails

                                                type ActivityContentDetails struct {
                                                	// Bulletin: The bulletin object contains details about a channel
                                                	// bulletin post. This object is only present if the snippet.type is
                                                	// bulletin.
                                                	Bulletin *ActivityContentDetailsBulletin `json:"bulletin,omitempty"`
                                                
                                                	// ChannelItem: The channelItem object contains details about a resource
                                                	// which was added to a channel. This property is only present if the
                                                	// snippet.type is channelItem.
                                                	ChannelItem *ActivityContentDetailsChannelItem `json:"channelItem,omitempty"`
                                                
                                                	// Comment: The comment object contains information about a resource
                                                	// that received a comment. This property is only present if the
                                                	// snippet.type is comment.
                                                	Comment *ActivityContentDetailsComment `json:"comment,omitempty"`
                                                
                                                	// Favorite: The favorite object contains information about a video that
                                                	// was marked as a favorite video. This property is only present if the
                                                	// snippet.type is favorite.
                                                	Favorite *ActivityContentDetailsFavorite `json:"favorite,omitempty"`
                                                
                                                	// Like: The like object contains information about a resource that
                                                	// received a positive (like) rating. This property is only present if
                                                	// the snippet.type is like.
                                                	Like *ActivityContentDetailsLike `json:"like,omitempty"`
                                                
                                                	// PlaylistItem: The playlistItem object contains information about a
                                                	// new playlist item. This property is only present if the snippet.type
                                                	// is playlistItem.
                                                	PlaylistItem *ActivityContentDetailsPlaylistItem `json:"playlistItem,omitempty"`
                                                
                                                	// PromotedItem: The promotedItem object contains details about a
                                                	// resource which is being promoted. This property is only present if
                                                	// the snippet.type is promotedItem.
                                                	PromotedItem *ActivityContentDetailsPromotedItem `json:"promotedItem,omitempty"`
                                                
                                                	// Recommendation: The recommendation object contains information about
                                                	// a recommended resource. This property is only present if the
                                                	// snippet.type is recommendation.
                                                	Recommendation *ActivityContentDetailsRecommendation `json:"recommendation,omitempty"`
                                                
                                                	// Social: The social object contains details about a social network
                                                	// post. This property is only present if the snippet.type is social.
                                                	Social *ActivityContentDetailsSocial `json:"social,omitempty"`
                                                
                                                	// Subscription: The subscription object contains information about a
                                                	// channel that a user subscribed to. This property is only present if
                                                	// the snippet.type is subscription.
                                                	Subscription *ActivityContentDetailsSubscription `json:"subscription,omitempty"`
                                                
                                                	// Upload: The upload object contains information about the uploaded
                                                	// video. This property is only present if the snippet.type is upload.
                                                	Upload *ActivityContentDetailsUpload `json:"upload,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "Bulletin") to
                                                	// unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "Bulletin") to include in
                                                	// API requests with the JSON null value. By default, fields with empty
                                                	// values are omitted from API requests. However, any field with an
                                                	// empty value appearing in NullFields will be sent to the server as
                                                	// null. It is an error if a field in this list has a non-empty value.
                                                	// This may be used to include null fields in Patch requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  ActivityContentDetails: Details about the content of an activity: the video that was shared, the channel that was subscribed to, etc.

                                                  func (*ActivityContentDetails) MarshalJSON

                                                  func (s *ActivityContentDetails) MarshalJSON() ([]byte, error)

                                                  type ActivityContentDetailsBulletin

                                                  type ActivityContentDetailsBulletin struct {
                                                  	// ResourceId: The resourceId object contains information that
                                                  	// identifies the resource associated with a bulletin post.
                                                  	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                  	// unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                  	// API requests with the JSON null value. By default, fields with empty
                                                  	// values are omitted from API requests. However, any field with an
                                                  	// empty value appearing in NullFields will be sent to the server as
                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                  	// This may be used to include null fields in Patch requests.
                                                  	NullFields []string `json:"-"`
                                                  }

                                                    ActivityContentDetailsBulletin: Details about a channel bulletin post.

                                                    func (*ActivityContentDetailsBulletin) MarshalJSON

                                                    func (s *ActivityContentDetailsBulletin) MarshalJSON() ([]byte, error)

                                                    type ActivityContentDetailsChannelItem

                                                    type ActivityContentDetailsChannelItem struct {
                                                    	// ResourceId: The resourceId object contains information that
                                                    	// identifies the resource that was added to the channel.
                                                    	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                    	// API requests with the JSON null value. By default, fields with empty
                                                    	// values are omitted from API requests. However, any field with an
                                                    	// empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

                                                      ActivityContentDetailsChannelItem: Details about a resource which was added to a channel.

                                                      func (*ActivityContentDetailsChannelItem) MarshalJSON

                                                      func (s *ActivityContentDetailsChannelItem) MarshalJSON() ([]byte, error)

                                                      type ActivityContentDetailsComment

                                                      type ActivityContentDetailsComment struct {
                                                      	// ResourceId: The resourceId object contains information that
                                                      	// identifies the resource associated with the comment.
                                                      	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                      
                                                      	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                      	// unconditionally include in API requests. By default, fields with
                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                      	// server regardless of whether the field is empty or not. This may be
                                                      	// used to include empty fields in Patch requests.
                                                      	ForceSendFields []string `json:"-"`
                                                      
                                                      	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                      	// API requests with the JSON null value. By default, fields with empty
                                                      	// values are omitted from API requests. However, any field with an
                                                      	// empty value appearing in NullFields will be sent to the server as
                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                      	// This may be used to include null fields in Patch requests.
                                                      	NullFields []string `json:"-"`
                                                      }

                                                        ActivityContentDetailsComment: Information about a resource that received a comment.

                                                        func (*ActivityContentDetailsComment) MarshalJSON

                                                        func (s *ActivityContentDetailsComment) MarshalJSON() ([]byte, error)

                                                        type ActivityContentDetailsFavorite

                                                        type ActivityContentDetailsFavorite struct {
                                                        	// ResourceId: The resourceId object contains information that
                                                        	// identifies the resource that was marked as a favorite.
                                                        	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                        	// API requests with the JSON null value. By default, fields with empty
                                                        	// values are omitted from API requests. However, any field with an
                                                        	// empty value appearing in NullFields will be sent to the server as
                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                        	// This may be used to include null fields in Patch requests.
                                                        	NullFields []string `json:"-"`
                                                        }

                                                          ActivityContentDetailsFavorite: Information about a video that was marked as a favorite video.

                                                          func (*ActivityContentDetailsFavorite) MarshalJSON

                                                          func (s *ActivityContentDetailsFavorite) MarshalJSON() ([]byte, error)

                                                          type ActivityContentDetailsLike

                                                          type ActivityContentDetailsLike struct {
                                                          	// ResourceId: The resourceId object contains information that
                                                          	// identifies the rated resource.
                                                          	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                          	// unconditionally include in API requests. By default, fields with
                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                          	// server regardless of whether the field is empty or not. This may be
                                                          	// used to include empty fields in Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                          	// API requests with the JSON null value. By default, fields with empty
                                                          	// values are omitted from API requests. However, any field with an
                                                          	// empty value appearing in NullFields will be sent to the server as
                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                          	// This may be used to include null fields in Patch requests.
                                                          	NullFields []string `json:"-"`
                                                          }

                                                            ActivityContentDetailsLike: Information about a resource that received a positive (like) rating.

                                                            func (*ActivityContentDetailsLike) MarshalJSON

                                                            func (s *ActivityContentDetailsLike) MarshalJSON() ([]byte, error)

                                                            type ActivityContentDetailsPlaylistItem

                                                            type ActivityContentDetailsPlaylistItem struct {
                                                            	// PlaylistId: The value that YouTube uses to uniquely identify the
                                                            	// playlist.
                                                            	PlaylistId string `json:"playlistId,omitempty"`
                                                            
                                                            	// PlaylistItemId: ID of the item within the playlist.
                                                            	PlaylistItemId string `json:"playlistItemId,omitempty"`
                                                            
                                                            	// ResourceId: The resourceId object contains information about the
                                                            	// resource that was added to the playlist.
                                                            	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "PlaylistId") to
                                                            	// unconditionally include in API requests. By default, fields with
                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                            	// server regardless of whether the field is empty or not. This may be
                                                            	// used to include empty fields in Patch requests.
                                                            	ForceSendFields []string `json:"-"`
                                                            
                                                            	// NullFields is a list of field names (e.g. "PlaylistId") to include in
                                                            	// API requests with the JSON null value. By default, fields with empty
                                                            	// values are omitted from API requests. However, any field with an
                                                            	// empty value appearing in NullFields will be sent to the server as
                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                            	// This may be used to include null fields in Patch requests.
                                                            	NullFields []string `json:"-"`
                                                            }

                                                              ActivityContentDetailsPlaylistItem: Information about a new playlist item.

                                                              func (*ActivityContentDetailsPlaylistItem) MarshalJSON

                                                              func (s *ActivityContentDetailsPlaylistItem) MarshalJSON() ([]byte, error)

                                                              type ActivityContentDetailsPromotedItem

                                                              type ActivityContentDetailsPromotedItem struct {
                                                              	// AdTag: The URL the client should fetch to request a promoted item.
                                                              	AdTag string `json:"adTag,omitempty"`
                                                              
                                                              	// ClickTrackingUrl: The URL the client should ping to indicate that the
                                                              	// user clicked through on this promoted item.
                                                              	ClickTrackingUrl string `json:"clickTrackingUrl,omitempty"`
                                                              
                                                              	// CreativeViewUrl: The URL the client should ping to indicate that the
                                                              	// user was shown this promoted item.
                                                              	CreativeViewUrl string `json:"creativeViewUrl,omitempty"`
                                                              
                                                              	// CtaType: The type of call-to-action, a message to the user indicating
                                                              	// action that can be taken.
                                                              	//
                                                              	// Possible values:
                                                              	//   "unspecified"
                                                              	//   "visitAdvertiserSite"
                                                              	CtaType string `json:"ctaType,omitempty"`
                                                              
                                                              	// CustomCtaButtonText: The custom call-to-action button text. If
                                                              	// specified, it will override the default button text for the cta_type.
                                                              	CustomCtaButtonText string `json:"customCtaButtonText,omitempty"`
                                                              
                                                              	// DescriptionText: The text description to accompany the promoted item.
                                                              	DescriptionText string `json:"descriptionText,omitempty"`
                                                              
                                                              	// DestinationUrl: The URL the client should direct the user to, if the
                                                              	// user chooses to visit the advertiser's website.
                                                              	DestinationUrl string `json:"destinationUrl,omitempty"`
                                                              
                                                              	// ForecastingUrl: The list of forecasting URLs. The client should ping
                                                              	// all of these URLs when a promoted item is not available, to indicate
                                                              	// that a promoted item could have been shown.
                                                              	ForecastingUrl []string `json:"forecastingUrl,omitempty"`
                                                              
                                                              	// ImpressionUrl: The list of impression URLs. The client should ping
                                                              	// all of these URLs to indicate that the user was shown this promoted
                                                              	// item.
                                                              	ImpressionUrl []string `json:"impressionUrl,omitempty"`
                                                              
                                                              	// VideoId: The ID that YouTube uses to uniquely identify the promoted
                                                              	// video.
                                                              	VideoId string `json:"videoId,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "AdTag") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "AdTag") to include in API
                                                              	// requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                                ActivityContentDetailsPromotedItem: Details about a resource which is being promoted.

                                                                func (*ActivityContentDetailsPromotedItem) MarshalJSON

                                                                func (s *ActivityContentDetailsPromotedItem) MarshalJSON() ([]byte, error)

                                                                type ActivityContentDetailsRecommendation

                                                                type ActivityContentDetailsRecommendation struct {
                                                                	// Reason: The reason that the resource is recommended to the user.
                                                                	//
                                                                	// Possible values:
                                                                	//   "unspecified"
                                                                	//   "videoFavorited"
                                                                	//   "videoLiked"
                                                                	//   "videoWatched"
                                                                	Reason string `json:"reason,omitempty"`
                                                                
                                                                	// ResourceId: The resourceId object contains information that
                                                                	// identifies the recommended resource.
                                                                	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                                
                                                                	// SeedResourceId: The seedResourceId object contains information about
                                                                	// the resource that caused the recommendation.
                                                                	SeedResourceId *ResourceId `json:"seedResourceId,omitempty"`
                                                                
                                                                	// ForceSendFields is a list of field names (e.g. "Reason") to
                                                                	// unconditionally include in API requests. By default, fields with
                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                	// server regardless of whether the field is empty or not. This may be
                                                                	// used to include empty fields in Patch requests.
                                                                	ForceSendFields []string `json:"-"`
                                                                
                                                                	// NullFields is a list of field names (e.g. "Reason") to include in API
                                                                	// requests with the JSON null value. By default, fields with empty
                                                                	// values are omitted from API requests. However, any field with an
                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                	// This may be used to include null fields in Patch requests.
                                                                	NullFields []string `json:"-"`
                                                                }

                                                                  ActivityContentDetailsRecommendation: Information that identifies the recommended resource.

                                                                  func (*ActivityContentDetailsRecommendation) MarshalJSON

                                                                  func (s *ActivityContentDetailsRecommendation) MarshalJSON() ([]byte, error)

                                                                  type ActivityContentDetailsSocial

                                                                  type ActivityContentDetailsSocial struct {
                                                                  	// Author: The author of the social network post.
                                                                  	Author string `json:"author,omitempty"`
                                                                  
                                                                  	// ImageUrl: An image of the post's author.
                                                                  	ImageUrl string `json:"imageUrl,omitempty"`
                                                                  
                                                                  	// ReferenceUrl: The URL of the social network post.
                                                                  	ReferenceUrl string `json:"referenceUrl,omitempty"`
                                                                  
                                                                  	// ResourceId: The resourceId object encapsulates information that
                                                                  	// identifies the resource associated with a social network post.
                                                                  	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                                  
                                                                  	// Type: The name of the social network.
                                                                  	//
                                                                  	// Possible values:
                                                                  	//   "facebook"
                                                                  	//   "googlePlus"
                                                                  	//   "twitter"
                                                                  	//   "unspecified"
                                                                  	Type string `json:"type,omitempty"`
                                                                  
                                                                  	// ForceSendFields is a list of field names (e.g. "Author") to
                                                                  	// unconditionally include in API requests. By default, fields with
                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                  	// used to include empty fields in Patch requests.
                                                                  	ForceSendFields []string `json:"-"`
                                                                  
                                                                  	// NullFields is a list of field names (e.g. "Author") to include in API
                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                  	// values are omitted from API requests. However, any field with an
                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                  	// This may be used to include null fields in Patch requests.
                                                                  	NullFields []string `json:"-"`
                                                                  }

                                                                    ActivityContentDetailsSocial: Details about a social network post.

                                                                    func (*ActivityContentDetailsSocial) MarshalJSON

                                                                    func (s *ActivityContentDetailsSocial) MarshalJSON() ([]byte, error)

                                                                    type ActivityContentDetailsSubscription

                                                                    type ActivityContentDetailsSubscription struct {
                                                                    	// ResourceId: The resourceId object contains information that
                                                                    	// identifies the resource that the user subscribed to.
                                                                    	ResourceId *ResourceId `json:"resourceId,omitempty"`
                                                                    
                                                                    	// ForceSendFields is a list of field names (e.g. "ResourceId") to
                                                                    	// unconditionally include in API requests. By default, fields with
                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                    	// used to include empty fields in Patch requests.
                                                                    	ForceSendFields []string `json:"-"`
                                                                    
                                                                    	// NullFields is a list of field names (e.g. "ResourceId") to include in
                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                    	// values are omitted from API requests. However, any field with an
                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                    	// This may be used to include null fields in Patch requests.
                                                                    	NullFields []string `json:"-"`
                                                                    }

                                                                      ActivityContentDetailsSubscription: Information about a channel that a user subscribed to.

                                                                      func (*ActivityContentDetailsSubscription) MarshalJSON

                                                                      func (s *ActivityContentDetailsSubscription) MarshalJSON() ([]byte, error)

                                                                      type ActivityContentDetailsUpload

                                                                      type ActivityContentDetailsUpload struct {
                                                                      	// VideoId: The ID that YouTube uses to uniquely identify the uploaded
                                                                      	// video.
                                                                      	VideoId string `json:"videoId,omitempty"`
                                                                      
                                                                      	// ForceSendFields is a list of field names (e.g. "VideoId") to
                                                                      	// unconditionally include in API requests. By default, fields with
                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                      	// used to include empty fields in Patch requests.
                                                                      	ForceSendFields []string `json:"-"`
                                                                      
                                                                      	// NullFields is a list of field names (e.g. "VideoId") to include in
                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                      	// values are omitted from API requests. However, any field with an
                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                      	// This may be used to include null fields in Patch requests.
                                                                      	NullFields []string `json:"-"`
                                                                      }

                                                                        ActivityContentDetailsUpload: Information about the uploaded video.

                                                                        func (*ActivityContentDetailsUpload) MarshalJSON

                                                                        func (s *ActivityContentDetailsUpload) MarshalJSON() ([]byte, error)

                                                                        type ActivityListResponse

                                                                        type ActivityListResponse struct {
                                                                        	// Etag: Etag of this resource.
                                                                        	Etag string `json:"etag,omitempty"`
                                                                        
                                                                        	// EventId: Serialized EventId of the request which produced this
                                                                        	// response.
                                                                        	EventId string `json:"eventId,omitempty"`
                                                                        
                                                                        	// Items: A list of activities, or events, that match the request
                                                                        	// criteria.
                                                                        	Items []*Activity `json:"items,omitempty"`
                                                                        
                                                                        	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                        	// string "youtube#activityListResponse".
                                                                        	Kind string `json:"kind,omitempty"`
                                                                        
                                                                        	// NextPageToken: The token that can be used as the value of the
                                                                        	// pageToken parameter to retrieve the next page in the result set.
                                                                        	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                        
                                                                        	PageInfo *PageInfo `json:"pageInfo,omitempty"`
                                                                        
                                                                        	// PrevPageToken: The token that can be used as the value of the
                                                                        	// pageToken parameter to retrieve the previous page in the result set.
                                                                        	PrevPageToken string `json:"prevPageToken,omitempty"`
                                                                        
                                                                        	TokenPagination *TokenPagination `json:"tokenPagination,omitempty"`
                                                                        
                                                                        	// VisitorId: The visitorId identifies the visitor.
                                                                        	VisitorId string `json:"visitorId,omitempty"`
                                                                        
                                                                        	// ServerResponse contains the HTTP response code and headers from the
                                                                        	// server.
                                                                        	googleapi.ServerResponse `json:"-"`
                                                                        
                                                                        	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                        	// unconditionally include in API requests. By default, fields with
                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                        	// used to include empty fields in Patch requests.
                                                                        	ForceSendFields []string `json:"-"`
                                                                        
                                                                        	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                        	// requests with the JSON null value. By default, fields with empty
                                                                        	// values are omitted from API requests. However, any field with an
                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                        	// This may be used to include null fields in Patch requests.
                                                                        	NullFields []string `json:"-"`
                                                                        }

                                                                        func (*ActivityListResponse) MarshalJSON

                                                                        func (s *ActivityListResponse) MarshalJSON() ([]byte, error)

                                                                        type ActivitySnippet

                                                                        type ActivitySnippet struct {
                                                                        	// ChannelId: The ID that YouTube uses to uniquely identify the channel
                                                                        	// associated with the activity.
                                                                        	ChannelId string `json:"channelId,omitempty"`
                                                                        
                                                                        	// ChannelTitle: Channel title for the channel responsible for this
                                                                        	// activity
                                                                        	ChannelTitle string `json:"channelTitle,omitempty"`
                                                                        
                                                                        	// Description: The description of the resource primarily associated
                                                                        	// with the activity.
                                                                        	Description string `json:"description,omitempty"`
                                                                        
                                                                        	// GroupId: The group ID associated with the activity. A group ID
                                                                        	// identifies user events that are associated with the same user and
                                                                        	// resource. For example, if a user rates a video and marks the same
                                                                        	// video as a favorite, the entries for those events would have the same
                                                                        	// group ID in the user's activity feed. In your user interface, you can
                                                                        	// avoid repetition by grouping events with the same groupId value.
                                                                        	GroupId string `json:"groupId,omitempty"`
                                                                        
                                                                        	// PublishedAt: The date and time that the video was uploaded. The value
                                                                        	// is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ) format.
                                                                        	PublishedAt string `json:"publishedAt,omitempty"`
                                                                        
                                                                        	// Thumbnails: A map of thumbnail images associated with the resource
                                                                        	// that is primarily associated with the activity. For each object in
                                                                        	// the map, the key is the name of the thumbnail image, and the value is
                                                                        	// an object that contains other information about the thumbnail.
                                                                        	Thumbnails *ThumbnailDetails `json:"thumbnails,omitempty"`
                                                                        
                                                                        	// Title: The title of the resource primarily associated with the
                                                                        	// activity.
                                                                        	Title string `json:"title,omitempty"`
                                                                        
                                                                        	// Type: The type of activity that the resource describes.
                                                                        	//
                                                                        	// Possible values:
                                                                        	//   "bulletin"
                                                                        	//   "channelItem"
                                                                        	//   "comment"
                                                                        	//   "favorite"
                                                                        	//   "like"
                                                                        	//   "playlistItem"
                                                                        	//   "promotedItem"
                                                                        	//   "recommendation"
                                                                        	//   "social"
                                                                        	//   "subscription"
                                                                        	//   "upload"
                                                                        	Type string `json:"type,omitempty"`
                                                                        
                                                                        	// ForceSendFields is a list of field names (e.g. "ChannelId") to
                                                                        	// unconditionally include in API requests. By default, fields with
                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                        	// used to include empty fields in Patch requests.
                                                                        	ForceSendFields []string `json:"-"`
                                                                        
                                                                        	// NullFields is a list of field names (e.g. "ChannelId") to include in
                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                        	// values are omitted from API requests. However, any field with an
                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                        	// This may be used to include null fields in Patch requests.
                                                                        	NullFields []string `json:"-"`
                                                                        }

                                                                          ActivitySnippet: Basic details about an activity, including title, description, thumbnails, activity type and group.

                                                                          func (*ActivitySnippet) MarshalJSON

                                                                          func (s *ActivitySnippet) MarshalJSON() ([]byte, error)

                                                                          type Caption

                                                                          type Caption struct {
                                                                          	// Etag: Etag of this resource.
                                                                          	Etag string `json:"etag,omitempty"`
                                                                          
                                                                          	// Id: The ID that YouTube uses to uniquely identify the caption track.
                                                                          	Id string `json:"id,omitempty"`
                                                                          
                                                                          	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                          	// string "youtube#caption".
                                                                          	Kind string `json:"kind,omitempty"`
                                                                          
                                                                          	// Snippet: The snippet object contains basic details about the caption.
                                                                          	Snippet *CaptionSnippet `json:"snippet,omitempty"`
                                                                          
                                                                          	// ServerResponse contains the HTTP response code and headers from the
                                                                          	// server.
                                                                          	googleapi.ServerResponse `json:"-"`
                                                                          
                                                                          	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                          	// unconditionally include in API requests. By default, fields with
                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                          	// used to include empty fields in Patch requests.
                                                                          	ForceSendFields []string `json:"-"`
                                                                          
                                                                          	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                          	// values are omitted from API requests. However, any field with an
                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                          	// This may be used to include null fields in Patch requests.
                                                                          	NullFields []string `json:"-"`
                                                                          }

                                                                            Caption: A caption resource represents a YouTube caption track. A caption track is associated with exactly one YouTube video.

                                                                            func (*Caption) MarshalJSON

                                                                            func (s *Caption) MarshalJSON() ([]byte, error)

                                                                            type CaptionListResponse

                                                                            type CaptionListResponse struct {
                                                                            	// Etag: Etag of this resource.
                                                                            	Etag string `json:"etag,omitempty"`
                                                                            
                                                                            	// EventId: Serialized EventId of the request which produced this
                                                                            	// response.
                                                                            	EventId string `json:"eventId,omitempty"`
                                                                            
                                                                            	// Items: A list of captions that match the request criteria.
                                                                            	Items []*Caption `json:"items,omitempty"`
                                                                            
                                                                            	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                            	// string "youtube#captionListResponse".
                                                                            	Kind string `json:"kind,omitempty"`
                                                                            
                                                                            	// VisitorId: The visitorId identifies the visitor.
                                                                            	VisitorId string `json:"visitorId,omitempty"`
                                                                            
                                                                            	// ServerResponse contains the HTTP response code and headers from the
                                                                            	// server.
                                                                            	googleapi.ServerResponse `json:"-"`
                                                                            
                                                                            	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                            	// unconditionally include in API requests. By default, fields with
                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                            	// used to include empty fields in Patch requests.
                                                                            	ForceSendFields []string `json:"-"`
                                                                            
                                                                            	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                            	// requests with the JSON null value. By default, fields with empty
                                                                            	// values are omitted from API requests. However, any field with an
                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                            	// This may be used to include null fields in Patch requests.
                                                                            	NullFields []string `json:"-"`
                                                                            }

                                                                            func (*CaptionListResponse) MarshalJSON

                                                                            func (s *CaptionListResponse) MarshalJSON() ([]byte, error)

                                                                            type CaptionSnippet

                                                                            type CaptionSnippet struct {
                                                                            	// AudioTrackType: The type of audio track associated with the caption
                                                                            	// track.
                                                                            	//
                                                                            	// Possible values:
                                                                            	//   "commentary"
                                                                            	//   "descriptive"
                                                                            	//   "primary"
                                                                            	//   "unknown"
                                                                            	AudioTrackType string `json:"audioTrackType,omitempty"`
                                                                            
                                                                            	// FailureReason: The reason that YouTube failed to process the caption
                                                                            	// track. This property is only present if the state property's value is
                                                                            	// failed.
                                                                            	//
                                                                            	// Possible values:
                                                                            	//   "processingFailed"
                                                                            	//   "unknownFormat"
                                                                            	//   "unsupportedFormat"
                                                                            	FailureReason string `json:"failureReason,omitempty"`
                                                                            
                                                                            	// IsAutoSynced: Indicates whether YouTube synchronized the caption
                                                                            	// track to the audio track in the video. The value will be true if a
                                                                            	// sync was explicitly requested when the caption track was uploaded.
                                                                            	// For example, when calling the captions.insert or captions.update
                                                                            	// methods, you can set the sync parameter to true to instruct YouTube
                                                                            	// to sync the uploaded track to the video. If the value is false,
                                                                            	// YouTube uses the time codes in the uploaded caption track to
                                                                            	// determine when to display captions.
                                                                            	IsAutoSynced bool `json:"isAutoSynced,omitempty"`
                                                                            
                                                                            	// IsCC: Indicates whether the track contains closed captions for the
                                                                            	// deaf and hard of hearing. The default value is false.
                                                                            	IsCC bool `json:"isCC,omitempty"`
                                                                            
                                                                            	// IsDraft: Indicates whether the caption track is a draft. If the value
                                                                            	// is true, then the track is not publicly visible. The default value is
                                                                            	// false.
                                                                            	IsDraft bool `json:"isDraft,omitempty"`
                                                                            
                                                                            	// IsEasyReader: Indicates whether caption track is formatted for "easy
                                                                            	// reader," meaning it is at a third-grade level for language learners.
                                                                            	// The default value is false.
                                                                            	IsEasyReader bool `json:"isEasyReader,omitempty"`
                                                                            
                                                                            	// IsLarge: Indicates whether the caption track uses large text for the
                                                                            	// vision-impaired. The default value is false.
                                                                            	IsLarge bool `json:"isLarge,omitempty"`
                                                                            
                                                                            	// Language: The language of the caption track. The property value is a
                                                                            	// BCP-47 language tag.
                                                                            	Language string `json:"language,omitempty"`
                                                                            
                                                                            	// LastUpdated: The date and time when the caption track was last
                                                                            	// updated. The value is specified in ISO 8601 (YYYY-MM-DDThh:mm:ss.sZ)
                                                                            	// format.
                                                                            	LastUpdated string `json:"lastUpdated,omitempty"`
                                                                            
                                                                            	// Name: The name of the caption track. The name is intended to be
                                                                            	// visible to the user as an option during playback.
                                                                            	Name string `json:"name,omitempty"`
                                                                            
                                                                            	// Status: The caption track's status.
                                                                            	//
                                                                            	// Possible values:
                                                                            	//   "failed"
                                                                            	//   "serving"
                                                                            	//   "syncing"
                                                                            	Status string `json:"status,omitempty"`
                                                                            
                                                                            	// TrackKind: The caption track's type.
                                                                            	//
                                                                            	// Possible values:
                                                                            	//   "ASR"
                                                                            	//   "forced"
                                                                            	//   "standard"
                                                                            	TrackKind string `json:"trackKind,omitempty"`
                                                                            
                                                                            	// VideoId: The ID that YouTube uses to uniquely identify the video
                                                                            	// associated with the caption track.
                                                                            	VideoId string `json:"videoId,omitempty"`
                                                                            
                                                                            	// ForceSendFields is a list of field names (e.g. "AudioTrackType") to
                                                                            	// unconditionally include in API requests. By default, fields with
                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                            	// used to include empty fields in Patch requests.
                                                                            	ForceSendFields []string `json:"-"`
                                                                            
                                                                            	// NullFields is a list of field names (e.g. "AudioTrackType") to
                                                                            	// include in API requests with the JSON null value. By default, fields
                                                                            	// with empty values are omitted from API requests. However, any field
                                                                            	// with an empty value appearing in NullFields will be sent to the
                                                                            	// server as null. It is an error if a field in this list has a
                                                                            	// non-empty value. This may be used to include null fields in Patch
                                                                            	// requests.
                                                                            	NullFields []string `json:"-"`
                                                                            }

                                                                              CaptionSnippet: Basic details about a caption track, such as its language and name.

                                                                              func (*CaptionSnippet) MarshalJSON

                                                                              func (s *CaptionSnippet) MarshalJSON() ([]byte, error)

                                                                              type CaptionsDeleteCall

                                                                              type CaptionsDeleteCall struct {
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                              func (*CaptionsDeleteCall) Context

                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                func (*CaptionsDeleteCall) Do

                                                                                  Do executes the "youtube.captions.delete" call.

                                                                                  func (*CaptionsDeleteCall) Fields

                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                    func (*CaptionsDeleteCall) Header

                                                                                    func (c *CaptionsDeleteCall) Header() http.Header

                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                      func (*CaptionsDeleteCall) OnBehalfOf

                                                                                      func (c *CaptionsDeleteCall) OnBehalfOf(onBehalfOf string) *CaptionsDeleteCall

                                                                                        OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page for the channel that the request is be on behalf of

                                                                                        func (*CaptionsDeleteCall) OnBehalfOfContentOwner

                                                                                        func (c *CaptionsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsDeleteCall

                                                                                          OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                          type CaptionsDownloadCall

                                                                                          type CaptionsDownloadCall struct {
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                          func (*CaptionsDownloadCall) Context

                                                                                            Context sets the context to be used in this call's Do and Download methods. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                            func (*CaptionsDownloadCall) Do

                                                                                              Do executes the "youtube.captions.download" call.

                                                                                              func (*CaptionsDownloadCall) Download

                                                                                              func (c *CaptionsDownloadCall) Download(opts ...googleapi.CallOption) (*http.Response, error)

                                                                                                Download fetches the API endpoint's "media" value, instead of the normal API response value. If the returned error is nil, the Response is guaranteed to have a 2xx status code. Callers must close the Response.Body as usual.

                                                                                                func (*CaptionsDownloadCall) Fields

                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                  func (*CaptionsDownloadCall) Header

                                                                                                  func (c *CaptionsDownloadCall) Header() http.Header

                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                    func (*CaptionsDownloadCall) IfNoneMatch

                                                                                                    func (c *CaptionsDownloadCall) IfNoneMatch(entityTag string) *CaptionsDownloadCall

                                                                                                      IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                      func (*CaptionsDownloadCall) OnBehalfOf

                                                                                                      func (c *CaptionsDownloadCall) OnBehalfOf(onBehalfOf string) *CaptionsDownloadCall

                                                                                                        OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page for the channel that the request is be on behalf of

                                                                                                        func (*CaptionsDownloadCall) OnBehalfOfContentOwner

                                                                                                        func (c *CaptionsDownloadCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsDownloadCall

                                                                                                          OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                          func (*CaptionsDownloadCall) Tfmt

                                                                                                            Tfmt sets the optional parameter "tfmt": The tfmt parameter specifies that the caption track should be returned in a specific format. If the parameter is not included in the request, the track is returned in its original format.

                                                                                                            Possible values:

                                                                                                            "sbv" - SubViewer subtitle.
                                                                                                            "scc" - Scenarist Closed Caption format.
                                                                                                            "srt" - SubRip subtitle.
                                                                                                            "ttml" - Timed Text Markup Language caption.
                                                                                                            "vtt" - Web Video Text Tracks caption.
                                                                                                            

                                                                                                            func (*CaptionsDownloadCall) Tlang

                                                                                                              Tlang sets the optional parameter "tlang": The tlang parameter specifies that the API response should return a translation of the specified caption track. The parameter value is an ISO 639-1 two-letter language code that identifies the desired caption language. The translation is generated by using machine translation, such as Google Translate.

                                                                                                              type CaptionsInsertCall

                                                                                                              type CaptionsInsertCall struct {
                                                                                                              	// contains filtered or unexported fields
                                                                                                              }

                                                                                                              func (*CaptionsInsertCall) Context

                                                                                                                Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled. This context will supersede any context previously provided to the ResumableMedia method.

                                                                                                                func (*CaptionsInsertCall) Do

                                                                                                                  Do executes the "youtube.captions.insert" call. Exactly one of *Caption or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Caption.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                  func (*CaptionsInsertCall) Fields

                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                    func (*CaptionsInsertCall) Header

                                                                                                                    func (c *CaptionsInsertCall) Header() http.Header

                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                      func (*CaptionsInsertCall) Media

                                                                                                                        Media specifies the media to upload in one or more chunks. The chunk size may be controlled by supplying a MediaOption generated by googleapi.ChunkSize. The chunk size defaults to googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload request will be determined by sniffing the contents of r, unless a MediaOption generated by googleapi.ContentType is supplied. At most one of Media and ResumableMedia may be set.

                                                                                                                        func (*CaptionsInsertCall) OnBehalfOf

                                                                                                                        func (c *CaptionsInsertCall) OnBehalfOf(onBehalfOf string) *CaptionsInsertCall

                                                                                                                          OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page for the channel that the request is be on behalf of

                                                                                                                          func (*CaptionsInsertCall) OnBehalfOfContentOwner

                                                                                                                          func (c *CaptionsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsInsertCall

                                                                                                                            OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                                            func (*CaptionsInsertCall) ProgressUpdater

                                                                                                                              ProgressUpdater provides a callback function that will be called after every chunk. It should be a low-latency function in order to not slow down the upload operation. This should only be called when using ResumableMedia (as opposed to Media).

                                                                                                                              func (*CaptionsInsertCall) ResumableMedia

                                                                                                                              func (c *CaptionsInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *CaptionsInsertCall

                                                                                                                                ResumableMedia specifies the media to upload in chunks and can be canceled with ctx.

                                                                                                                                Deprecated: use Media instead.

                                                                                                                                At most one of Media and ResumableMedia may be set. mediaType identifies the MIME media type of the upload, such as "image/png". If mediaType is "", it will be auto-detected. The provided ctx will supersede any context previously provided to the Context method.

                                                                                                                                func (*CaptionsInsertCall) Sync

                                                                                                                                  Sync sets the optional parameter "sync": The sync parameter indicates whether YouTube should automatically synchronize the caption file with the audio track of the video. If you set the value to true, YouTube will disregard any time codes that are in the uploaded caption file and generate new time codes for the captions.

                                                                                                                                  You should set the sync parameter to true if you are uploading a transcript, which has no time codes, or if you suspect the time codes in your file are incorrect and want YouTube to try to fix them.

                                                                                                                                  type CaptionsListCall

                                                                                                                                  type CaptionsListCall struct {
                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                  }

                                                                                                                                  func (*CaptionsListCall) Context

                                                                                                                                    Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                    func (*CaptionsListCall) Do

                                                                                                                                      Do executes the "youtube.captions.list" call. Exactly one of *CaptionListResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *CaptionListResponse.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                      func (*CaptionsListCall) Fields

                                                                                                                                        Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                        func (*CaptionsListCall) Header

                                                                                                                                        func (c *CaptionsListCall) Header() http.Header

                                                                                                                                          Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                          func (*CaptionsListCall) Id

                                                                                                                                            Id sets the optional parameter "id": The id parameter specifies a comma-separated list of IDs that identify the caption resources that should be retrieved. Each ID must identify a caption track associated with the specified video.

                                                                                                                                            func (*CaptionsListCall) IfNoneMatch

                                                                                                                                            func (c *CaptionsListCall) IfNoneMatch(entityTag string) *CaptionsListCall

                                                                                                                                              IfNoneMatch sets the optional parameter which makes the operation fail if the object's ETag matches the given value. This is useful for getting updates only after the object has changed since the last request. Use googleapi.IsNotModified to check whether the response error from Do is the result of In-None-Match.

                                                                                                                                              func (*CaptionsListCall) OnBehalfOf

                                                                                                                                              func (c *CaptionsListCall) OnBehalfOf(onBehalfOf string) *CaptionsListCall

                                                                                                                                                OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page for the channel that the request is on behalf of.

                                                                                                                                                func (*CaptionsListCall) OnBehalfOfContentOwner

                                                                                                                                                func (c *CaptionsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsListCall

                                                                                                                                                  OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                                                                  type CaptionsService

                                                                                                                                                  type CaptionsService struct {
                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                  }

                                                                                                                                                  func NewCaptionsService

                                                                                                                                                  func NewCaptionsService(s *Service) *CaptionsService

                                                                                                                                                  func (*CaptionsService) Delete

                                                                                                                                                  func (r *CaptionsService) Delete(id string) *CaptionsDeleteCall

                                                                                                                                                    Delete: Deletes a specified caption track.

                                                                                                                                                    func (*CaptionsService) Download

                                                                                                                                                    func (r *CaptionsService) Download(id string) *CaptionsDownloadCall

                                                                                                                                                      Download: Downloads a caption track. The caption track is returned in its original format unless the request specifies a value for the tfmt parameter and in its original language unless the request specifies a value for the tlang parameter.

                                                                                                                                                      func (*CaptionsService) Insert

                                                                                                                                                      func (r *CaptionsService) Insert(part string, caption *Caption) *CaptionsInsertCall

                                                                                                                                                        Insert: Uploads a caption track.

                                                                                                                                                        func (*CaptionsService) List

                                                                                                                                                        func (r *CaptionsService) List(part string, videoId string) *CaptionsListCall

                                                                                                                                                          List: Returns a list of caption tracks that are associated with a specified video. Note that the API response does not contain the actual captions and that the captions.download method provides the ability to retrieve a caption track.

                                                                                                                                                          func (*CaptionsService) Update

                                                                                                                                                          func (r *CaptionsService) Update(part string, caption *Caption) *CaptionsUpdateCall

                                                                                                                                                            Update: Updates a caption track. When updating a caption track, you can change the track's draft status, upload a new caption file for the track, or both.

                                                                                                                                                            type CaptionsUpdateCall

                                                                                                                                                            type CaptionsUpdateCall struct {
                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                            }

                                                                                                                                                            func (*CaptionsUpdateCall) Context

                                                                                                                                                              Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled. This context will supersede any context previously provided to the ResumableMedia method.

                                                                                                                                                              func (*CaptionsUpdateCall) Do

                                                                                                                                                                Do executes the "youtube.captions.update" call. Exactly one of *Caption or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Caption.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                func (*CaptionsUpdateCall) Fields

                                                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                  func (*CaptionsUpdateCall) Header

                                                                                                                                                                  func (c *CaptionsUpdateCall) Header() http.Header

                                                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                    func (*CaptionsUpdateCall) Media

                                                                                                                                                                      Media specifies the media to upload in one or more chunks. The chunk size may be controlled by supplying a MediaOption generated by googleapi.ChunkSize. The chunk size defaults to googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload request will be determined by sniffing the contents of r, unless a MediaOption generated by googleapi.ContentType is supplied. At most one of Media and ResumableMedia may be set.

                                                                                                                                                                      func (*CaptionsUpdateCall) OnBehalfOf

                                                                                                                                                                      func (c *CaptionsUpdateCall) OnBehalfOf(onBehalfOf string) *CaptionsUpdateCall

                                                                                                                                                                        OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page for the channel that the request is be on behalf of

                                                                                                                                                                        func (*CaptionsUpdateCall) OnBehalfOfContentOwner

                                                                                                                                                                        func (c *CaptionsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsUpdateCall

                                                                                                                                                                          OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                                                                                          func (*CaptionsUpdateCall) ProgressUpdater

                                                                                                                                                                            ProgressUpdater provides a callback function that will be called after every chunk. It should be a low-latency function in order to not slow down the upload operation. This should only be called when using ResumableMedia (as opposed to Media).

                                                                                                                                                                            func (*CaptionsUpdateCall) ResumableMedia

                                                                                                                                                                            func (c *CaptionsUpdateCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *CaptionsUpdateCall

                                                                                                                                                                              ResumableMedia specifies the media to upload in chunks and can be canceled with ctx.

                                                                                                                                                                              Deprecated: use Media instead.

                                                                                                                                                                              At most one of Media and ResumableMedia may be set. mediaType identifies the MIME media type of the upload, such as "image/png". If mediaType is "", it will be auto-detected. The provided ctx will supersede any context previously provided to the Context method.

                                                                                                                                                                              func (*CaptionsUpdateCall) Sync

                                                                                                                                                                                Sync sets the optional parameter "sync": Note: The API server only processes the parameter value if the request contains an updated caption file.

                                                                                                                                                                                The sync parameter indicates whether YouTube should automatically synchronize the caption file with the audio track of the video. If you set the value to true, YouTube will automatically synchronize the caption track with the audio track.

                                                                                                                                                                                type CdnSettings

                                                                                                                                                                                type CdnSettings struct {
                                                                                                                                                                                	// Format: The format of the video stream that you are sending to
                                                                                                                                                                                	// Youtube.
                                                                                                                                                                                	Format string `json:"format,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// FrameRate: The frame rate of the inbound video data.
                                                                                                                                                                                	//
                                                                                                                                                                                	// Possible values:
                                                                                                                                                                                	//   "30fps"
                                                                                                                                                                                	//   "60fps"
                                                                                                                                                                                	//   "variable"
                                                                                                                                                                                	FrameRate string `json:"frameRate,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// IngestionInfo: The ingestionInfo object contains information that
                                                                                                                                                                                	// YouTube provides that you need to transmit your RTMP or HTTP stream
                                                                                                                                                                                	// to YouTube.
                                                                                                                                                                                	IngestionInfo *IngestionInfo `json:"ingestionInfo,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// IngestionType: The method or protocol used to transmit the video
                                                                                                                                                                                	// stream.
                                                                                                                                                                                	//
                                                                                                                                                                                	// Possible values:
                                                                                                                                                                                	//   "dash"
                                                                                                                                                                                	//   "hls"
                                                                                                                                                                                	//   "rtmp"
                                                                                                                                                                                	//   "webrtc"
                                                                                                                                                                                	IngestionType string `json:"ingestionType,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// Resolution: The resolution of the inbound video data.
                                                                                                                                                                                	//
                                                                                                                                                                                	// Possible values:
                                                                                                                                                                                	//   "1080p"
                                                                                                                                                                                	//   "1440p"
                                                                                                                                                                                	//   "2160p"
                                                                                                                                                                                	//   "240p"
                                                                                                                                                                                	//   "360p"
                                                                                                                                                                                	//   "480p"
                                                                                                                                                                                	//   "720p"
                                                                                                                                                                                	//   "variable"
                                                                                                                                                                                	Resolution string `json:"resolution,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Format") to
                                                                                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                                
                                                                                                                                                                                	// NullFields is a list of field names (e.g. "Format") to include in API
                                                                                                                                                                                	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                	NullFields []string `json:"-"`
                                                                                                                                                                                }

                                                                                                                                                                                  CdnSettings: Brief description of the live stream cdn settings.

                                                                                                                                                                                  func (*CdnSettings) MarshalJSON

                                                                                                                                                                                  func (s *CdnSettings) MarshalJSON() ([]byte, error)

                                                                                                                                                                                  type Channel

                                                                                                                                                                                  type Channel struct {
                                                                                                                                                                                  	// AuditDetails: The auditionDetails object encapsulates channel data
                                                                                                                                                                                  	// that is relevant for YouTube Partners during the audition process.
                                                                                                                                                                                  	AuditDetails *ChannelAuditDetails `json:"auditDetails,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// BrandingSettings: The brandingSettings object encapsulates
                                                                                                                                                                                  	// information about the branding of the channel.
                                                                                                                                                                                  	BrandingSettings *ChannelBrandingSettings `json:"brandingSettings,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ContentDetails: The contentDetails object encapsulates information
                                                                                                                                                                                  	// about the channel's content.
                                                                                                                                                                                  	ContentDetails *ChannelContentDetails `json:"contentDetails,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ContentOwnerDetails: The contentOwnerDetails object encapsulates
                                                                                                                                                                                  	// channel data that is relevant for YouTube Partners linked with the
                                                                                                                                                                                  	// channel.
                                                                                                                                                                                  	ContentOwnerDetails *ChannelContentOwnerDetails `json:"contentOwnerDetails,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ConversionPings: The conversionPings object encapsulates information
                                                                                                                                                                                  	// about conversion pings that need to be respected by the channel.
                                                                                                                                                                                  	ConversionPings *ChannelConversionPings `json:"conversionPings,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Etag: Etag of this resource.
                                                                                                                                                                                  	Etag string `json:"etag,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Id: The ID that YouTube uses to uniquely identify the channel.
                                                                                                                                                                                  	Id string `json:"id,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// InvideoPromotion: The invideoPromotion object encapsulates
                                                                                                                                                                                  	// information about promotion campaign associated with the channel.
                                                                                                                                                                                  	InvideoPromotion *InvideoPromotion `json:"invideoPromotion,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                  	// string "youtube#channel".
                                                                                                                                                                                  	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Localizations: Localizations for different languages
                                                                                                                                                                                  	Localizations map[string]ChannelLocalization `json:"localizations,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Snippet: The snippet object contains basic details about the channel,
                                                                                                                                                                                  	// such as its title, description, and thumbnail images.
                                                                                                                                                                                  	Snippet *ChannelSnippet `json:"snippet,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Statistics: The statistics object encapsulates statistics for the
                                                                                                                                                                                  	// channel.
                                                                                                                                                                                  	Statistics *ChannelStatistics `json:"statistics,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// Status: The status object encapsulates information about the privacy
                                                                                                                                                                                  	// status of the channel.
                                                                                                                                                                                  	Status *ChannelStatus `json:"status,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// TopicDetails: The topicDetails object encapsulates information about
                                                                                                                                                                                  	// Freebase topics associated with the channel.
                                                                                                                                                                                  	TopicDetails *ChannelTopicDetails `json:"topicDetails,omitempty"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                  	// server.
                                                                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "AuditDetails") to
                                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// NullFields is a list of field names (e.g. "AuditDetails") to include
                                                                                                                                                                                  	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                  	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                  	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                  }

                                                                                                                                                                                    Channel: A channel resource contains information about a YouTube channel.

                                                                                                                                                                                    func (*Channel) MarshalJSON

                                                                                                                                                                                    func (s *Channel) MarshalJSON() ([]byte, error)

                                                                                                                                                                                    type ChannelAuditDetails

                                                                                                                                                                                    type ChannelAuditDetails struct {
                                                                                                                                                                                    	// CommunityGuidelinesGoodStanding: Whether or not the channel respects
                                                                                                                                                                                    	// the community guidelines.
                                                                                                                                                                                    	CommunityGuidelinesGoodStanding bool `json:"communityGuidelinesGoodStanding,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// ContentIdClaimsGoodStanding: Whether or not the channel has any
                                                                                                                                                                                    	// unresolved claims.
                                                                                                                                                                                    	ContentIdClaimsGoodStanding bool `json:"contentIdClaimsGoodStanding,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// CopyrightStrikesGoodStanding: Whether or not the channel has any
                                                                                                                                                                                    	// copyright strikes.
                                                                                                                                                                                    	CopyrightStrikesGoodStanding bool `json:"copyrightStrikesGoodStanding,omitempty"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g.
                                                                                                                                                                                    	// "CommunityGuidelinesGoodStanding") to unconditionally include in API
                                                                                                                                                                                    	// requests. By default, fields with empty values are omitted from API
                                                                                                                                                                                    	// requests. However, any non-pointer, non-interface field appearing in
                                                                                                                                                                                    	// ForceSendFields will be sent to the server regardless of whether the
                                                                                                                                                                                    	// field is empty or not. This may be used to include empty fields in
                                                                                                                                                                                    	// Patch requests.
                                                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                                                    
                                                                                                                                                                                    	// NullFields is a list of field names (e.g.
                                                                                                                                                                                    	// "CommunityGuidelinesGoodStanding") to include in API requests with
                                                                                                                                                                                    	// the JSON null value. By default, fields with empty values are omitted
                                                                                                                                                                                    	// from API requests. However, any field with an empty value appearing
                                                                                                                                                                                    	// in NullFields will be sent to the server as null. It is an error if a
                                                                                                                                                                                    	// field in this list has a non-empty value. This may be used to include
                                                                                                                                                                                    	// null fields in Patch requests.
                                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                                    }

                                                                                                                                                                                      ChannelAuditDetails: The auditDetails object encapsulates channel data that is relevant for YouTube Partners during the audit process.

                                                                                                                                                                                      func (*ChannelAuditDetails) MarshalJSON

                                                                                                                                                                                      func (s *ChannelAuditDetails) MarshalJSON() ([]byte, error)

                                                                                                                                                                                      type ChannelBannerResource

                                                                                                                                                                                      type ChannelBannerResource struct {
                                                                                                                                                                                      	// Etag: Etag of this resource.
                                                                                                                                                                                      	Etag string `json:"etag,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                      	// string "youtube#channelBannerResource".
                                                                                                                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// Url: The URL of this banner image.
                                                                                                                                                                                      	Url string `json:"url,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                      	// server.
                                                                                                                                                                                      	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                                                                                                                                      	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                                                      }

                                                                                                                                                                                        ChannelBannerResource: A channel banner returned as the response to a channel_banner.insert call.

                                                                                                                                                                                        func (*ChannelBannerResource) MarshalJSON

                                                                                                                                                                                        func (s *ChannelBannerResource) MarshalJSON() ([]byte, error)

                                                                                                                                                                                        type ChannelBannersInsertCall

                                                                                                                                                                                        type ChannelBannersInsertCall struct {
                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                        }

                                                                                                                                                                                        func (*ChannelBannersInsertCall) ChannelId

                                                                                                                                                                                        func (c *ChannelBannersInsertCall) ChannelId(channelId string) *ChannelBannersInsertCall

                                                                                                                                                                                          ChannelId sets the optional parameter "channelId": The channelId parameter identifies the YouTube channel to which the banner is uploaded. The channelId parameter was introduced as a required parameter in May 2017. As this was a backward-incompatible change, channelBanners.insert requests that do not specify this parameter will not return an error until six months have passed from the time that the parameter was introduced. Please see the API Terms of Service for the official policy regarding backward incompatible changes and the API revision history for the exact date that the parameter was introduced.

                                                                                                                                                                                          func (*ChannelBannersInsertCall) Context

                                                                                                                                                                                            Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled. This context will supersede any context previously provided to the ResumableMedia method.

                                                                                                                                                                                            func (*ChannelBannersInsertCall) Do

                                                                                                                                                                                              Do executes the "youtube.channelBanners.insert" call. Exactly one of *ChannelBannerResource or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ChannelBannerResource.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                              func (*ChannelBannersInsertCall) Fields

                                                                                                                                                                                                Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                func (*ChannelBannersInsertCall) Header

                                                                                                                                                                                                func (c *ChannelBannersInsertCall) Header() http.Header

                                                                                                                                                                                                  Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                  func (*ChannelBannersInsertCall) Media

                                                                                                                                                                                                    Media specifies the media to upload in one or more chunks. The chunk size may be controlled by supplying a MediaOption generated by googleapi.ChunkSize. The chunk size defaults to googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload request will be determined by sniffing the contents of r, unless a MediaOption generated by googleapi.ContentType is supplied. At most one of Media and ResumableMedia may be set.

                                                                                                                                                                                                    func (*ChannelBannersInsertCall) OnBehalfOfContentOwner

                                                                                                                                                                                                    func (c *ChannelBannersInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelBannersInsertCall

                                                                                                                                                                                                      OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                                                                                                                      func (*ChannelBannersInsertCall) ProgressUpdater

                                                                                                                                                                                                        ProgressUpdater provides a callback function that will be called after every chunk. It should be a low-latency function in order to not slow down the upload operation. This should only be called when using ResumableMedia (as opposed to Media).

                                                                                                                                                                                                        func (*ChannelBannersInsertCall) ResumableMedia

                                                                                                                                                                                                        func (c *ChannelBannersInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *ChannelBannersInsertCall

                                                                                                                                                                                                          ResumableMedia specifies the media to upload in chunks and can be canceled with ctx.

                                                                                                                                                                                                          Deprecated: use Media instead.

                                                                                                                                                                                                          At most one of Media and ResumableMedia may be set. mediaType identifies the MIME media type of the upload, such as "image/png". If mediaType is "", it will be auto-detected. The provided ctx will supersede any context previously provided to the Context method.

                                                                                                                                                                                                          type ChannelBannersService

                                                                                                                                                                                                          type ChannelBannersService struct {
                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                          }

                                                                                                                                                                                                          func NewChannelBannersService

                                                                                                                                                                                                          func NewChannelBannersService(s *Service) *ChannelBannersService

                                                                                                                                                                                                          func (*ChannelBannersService) Insert

                                                                                                                                                                                                          func (r *ChannelBannersService) Insert(channelbannerresource *ChannelBannerResource) *ChannelBannersInsertCall

                                                                                                                                                                                                            Insert: Uploads a channel banner image to YouTube. This method represents the first two steps in a three-step process to update the banner image for a channel:

                                                                                                                                                                                                            - Call the channelBanners.insert method to upload the binary image data to YouTube. The image must have a 16:9 aspect ratio and be at least 2120x1192 pixels. - Extract the url property's value from the response that the API returns for step 1. - Call the channels.update method to update the channel's branding settings. Set the brandingSettings.image.bannerExternalUrl property's value to the URL obtained in step 2.

                                                                                                                                                                                                            type ChannelBrandingSettings

                                                                                                                                                                                                            type ChannelBrandingSettings struct {
                                                                                                                                                                                                            	// Channel: Branding properties for the channel view.
                                                                                                                                                                                                            	Channel *ChannelSettings `json:"channel,omitempty"`
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Hints: Additional experimental branding properties.
                                                                                                                                                                                                            	Hints []*PropertyValue `json:"hints,omitempty"`
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Image: Branding properties for branding images.
                                                                                                                                                                                                            	Image *ImageSettings `json:"image,omitempty"`
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Watch: Branding properties for the watch page.
                                                                                                                                                                                                            	Watch *WatchSettings `json:"watch,omitempty"`
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "Channel") to
                                                                                                                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// NullFields is a list of field names (e.g. "Channel") to include in
                                                                                                                                                                                                            	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                            	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                                                            }

                                                                                                                                                                                                              ChannelBrandingSettings: Branding properties of a YouTube channel.

                                                                                                                                                                                                              func (*ChannelBrandingSettings) MarshalJSON

                                                                                                                                                                                                              func (s *ChannelBrandingSettings) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                              type ChannelContentDetails

                                                                                                                                                                                                              type ChannelContentDetails struct {
                                                                                                                                                                                                              	RelatedPlaylists *ChannelContentDetailsRelatedPlaylists `json:"relatedPlaylists,omitempty"`
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "RelatedPlaylists") to
                                                                                                                                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                              	// used to include empty fields in Patch requests.
                                                                                                                                                                                                              	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// NullFields is a list of field names (e.g. "RelatedPlaylists") to
                                                                                                                                                                                                              	// include in API requests with the JSON null value. By default, fields
                                                                                                                                                                                                              	// with empty values are omitted from API requests. However, any field
                                                                                                                                                                                                              	// with an empty value appearing in NullFields will be sent to the
                                                                                                                                                                                                              	// server as null. It is an error if a field in this list has a
                                                                                                                                                                                                              	// non-empty value. This may be used to include null fields in Patch
                                                                                                                                                                                                              	// requests.
                                                                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                ChannelContentDetails: Details about the content of a channel.

                                                                                                                                                                                                                func (*ChannelContentDetails) MarshalJSON

                                                                                                                                                                                                                func (s *ChannelContentDetails) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                type ChannelContentDetailsRelatedPlaylists

                                                                                                                                                                                                                type ChannelContentDetailsRelatedPlaylists struct {
                                                                                                                                                                                                                	// Favorites: The ID of the playlist that contains the channel"s
                                                                                                                                                                                                                	// favorite videos. Use the  playlistItems.insert and
                                                                                                                                                                                                                	// playlistItems.delete to add or remove items from that list.
                                                                                                                                                                                                                	Favorites string `json:"favorites,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Likes: The ID of the playlist that contains the channel"s liked
                                                                                                                                                                                                                	// videos. Use the   playlistItems.insert and  playlistItems.delete to
                                                                                                                                                                                                                	// add or remove items from that list.
                                                                                                                                                                                                                	Likes string `json:"likes,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// Uploads: The ID of the playlist that contains the channel"s uploaded
                                                                                                                                                                                                                	// videos. Use the  videos.insert method to upload new videos and the
                                                                                                                                                                                                                	// videos.delete method to delete previously uploaded videos.
                                                                                                                                                                                                                	Uploads string `json:"uploads,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// WatchHistory: The ID of the playlist that contains the channel"s
                                                                                                                                                                                                                	// watch history. Use the  playlistItems.insert and
                                                                                                                                                                                                                	// playlistItems.delete to add or remove items from that list.
                                                                                                                                                                                                                	WatchHistory string `json:"watchHistory,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// WatchLater: The ID of the playlist that contains the channel"s watch
                                                                                                                                                                                                                	// later playlist. Use the playlistItems.insert and
                                                                                                                                                                                                                	// playlistItems.delete to add or remove items from that list.
                                                                                                                                                                                                                	WatchLater string `json:"watchLater,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Favorites") to
                                                                                                                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// NullFields is a list of field names (e.g. "Favorites") to include in
                                                                                                                                                                                                                	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                	NullFields []string `json:"-"`
                                                                                                                                                                                                                }

                                                                                                                                                                                                                func (*ChannelContentDetailsRelatedPlaylists) MarshalJSON

                                                                                                                                                                                                                func (s *ChannelContentDetailsRelatedPlaylists) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                type ChannelContentOwnerDetails

                                                                                                                                                                                                                type ChannelContentOwnerDetails struct {
                                                                                                                                                                                                                	// ContentOwner: The ID of the content owner linked to the channel.
                                                                                                                                                                                                                	ContentOwner string `json:"contentOwner,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// TimeLinked: The date and time of when the channel was linked to the
                                                                                                                                                                                                                	// content owner. The value is specified in ISO 8601
                                                                                                                                                                                                                	// (YYYY-MM-DDThh:mm:ss.sZ) format.
                                                                                                                                                                                                                	TimeLinked string `json:"timeLinked,omitempty"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "ContentOwner") to
                                                                                                                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                
                                                                                                                                                                                                                	// NullFields is a list of field names (e.g. "ContentOwner") to include
                                                                                                                                                                                                                	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                	NullFields []string `json:"-"`
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  ChannelContentOwnerDetails: The contentOwnerDetails object encapsulates channel data that is relevant for YouTube Partners linked with the channel.

                                                                                                                                                                                                                  func (*ChannelContentOwnerDetails) MarshalJSON

                                                                                                                                                                                                                  func (s *ChannelContentOwnerDetails) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                  type ChannelConversionPing

                                                                                                                                                                                                                  type ChannelConversionPing struct {
                                                                                                                                                                                                                  	// Context: Defines the context of the ping.
                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                  	// Possible values:
                                                                                                                                                                                                                  	//   "cview"
                                                                                                                                                                                                                  	//   "subscribe"
                                                                                                                                                                                                                  	//   "unsubscribe"
                                                                                                                                                                                                                  	Context string `json:"context,omitempty"`
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// ConversionUrl: The url (without the schema) that the player shall
                                                                                                                                                                                                                  	// send the ping to. It's at caller's descretion to decide which schema
                                                                                                                                                                                                                  	// to use (http vs https) Example of a returned url:
                                                                                                                                                                                                                  	// //googleads.g.doubleclick.net/pagead/
                                                                                                                                                                                                                  	// viewthroughconversion/962985656/?data=path%3DtHe_path%3Btype%3D
                                                                                                                                                                                                                  	// cview%3Butuid%3DGISQtTNGYqaYl4sKxoVvKA&labe=default The caller must
                                                                                                                                                                                                                  	// append biscotti authentication (ms param in case of mobile, for
                                                                                                                                                                                                                  	// example) to this ping.
                                                                                                                                                                                                                  	ConversionUrl string `json:"conversionUrl,omitempty"`
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "Context") to
                                                                                                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// NullFields is a list of field names (e.g. "Context") to include in
                                                                                                                                                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                  	NullFields []string `json:"-"`
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    ChannelConversionPing: Pings that the app shall fire (authenticated by biscotti cookie). Each ping has a context, in which the app must fire the ping, and a url identifying the ping.

                                                                                                                                                                                                                    func (*ChannelConversionPing) MarshalJSON

                                                                                                                                                                                                                    func (s *ChannelConversionPing) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                    type ChannelConversionPings

                                                                                                                                                                                                                    type ChannelConversionPings struct {
                                                                                                                                                                                                                    	// Pings: Pings that the app shall fire (authenticated by biscotti
                                                                                                                                                                                                                    	// cookie). Each ping has a context, in which the app must fire the
                                                                                                                                                                                                                    	// ping, and a url identifying the ping.
                                                                                                                                                                                                                    	Pings []*ChannelConversionPing `json:"pings,omitempty"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "Pings") to
                                                                                                                                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// NullFields is a list of field names (e.g. "Pings") to include in API
                                                                                                                                                                                                                    	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                    	NullFields []string `json:"-"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      ChannelConversionPings: The conversionPings object encapsulates information about conversion pings that need to be respected by the channel.

                                                                                                                                                                                                                      func (*ChannelConversionPings) MarshalJSON

                                                                                                                                                                                                                      func (s *ChannelConversionPings) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                      type ChannelListResponse

                                                                                                                                                                                                                      type ChannelListResponse struct {
                                                                                                                                                                                                                      	// Etag: Etag of this resource.
                                                                                                                                                                                                                      	Etag string `json:"etag,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// EventId: Serialized EventId of the request which produced this
                                                                                                                                                                                                                      	// response.
                                                                                                                                                                                                                      	EventId string `json:"eventId,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Items: A list of channels that match the request criteria.
                                                                                                                                                                                                                      	Items []*Channel `json:"items,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                                                      	// string "youtube#channelListResponse".
                                                                                                                                                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// NextPageToken: The token that can be used as the value of the
                                                                                                                                                                                                                      	// pageToken parameter to retrieve the next page in the result set.
                                                                                                                                                                                                                      	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	PageInfo *PageInfo `json:"pageInfo,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// PrevPageToken: The token that can be used as the value of the
                                                                                                                                                                                                                      	// pageToken parameter to retrieve the previous page in the result set.
                                                                                                                                                                                                                      	PrevPageToken string `json:"prevPageToken,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	TokenPagination *TokenPagination `json:"tokenPagination,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// VisitorId: The visitorId identifies the visitor.
                                                                                                                                                                                                                      	VisitorId string `json:"visitorId,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                      	// server.
                                                                                                                                                                                                                      	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                                                                                                                                                                      	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                      func (*ChannelListResponse) MarshalJSON

                                                                                                                                                                                                                      func (s *ChannelListResponse) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                      type ChannelLocalization

                                                                                                                                                                                                                      type ChannelLocalization struct {
                                                                                                                                                                                                                      	// Description: The localized strings for channel's description.
                                                                                                                                                                                                                      	Description string `json:"description,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Title: The localized strings for channel's title.
                                                                                                                                                                                                                      	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "Description") to
                                                                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// NullFields is a list of field names (e.g. "Description") to include
                                                                                                                                                                                                                      	// in API requests with the JSON null value. By default, fields with
                                                                                                                                                                                                                      	// empty values are omitted from API requests. However, any field with
                                                                                                                                                                                                                      	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        ChannelLocalization: Channel localization setting

                                                                                                                                                                                                                        func (*ChannelLocalization) MarshalJSON

                                                                                                                                                                                                                        func (s *ChannelLocalization) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                        type ChannelProfileDetails

                                                                                                                                                                                                                        type ChannelProfileDetails struct {
                                                                                                                                                                                                                        	// ChannelId: The YouTube channel ID.
                                                                                                                                                                                                                        	ChannelId string `json:"channelId,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ChannelUrl: The channel's URL.
                                                                                                                                                                                                                        	ChannelUrl string `json:"channelUrl,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// DisplayName: The channel's display name.
                                                                                                                                                                                                                        	DisplayName string `json:"displayName,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ProfileImageUrl: The channels's avatar URL.
                                                                                                                                                                                                                        	ProfileImageUrl string `json:"profileImageUrl,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "ChannelId") to
                                                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "ChannelId") to include in
                                                                                                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                        func (*ChannelProfileDetails) MarshalJSON

                                                                                                                                                                                                                        func (s *ChannelProfileDetails) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                        type ChannelSection

                                                                                                                                                                                                                        type ChannelSection struct {
                                                                                                                                                                                                                        	// ContentDetails: The contentDetails object contains details about the
                                                                                                                                                                                                                        	// channel section content, such as a list of playlists or channels
                                                                                                                                                                                                                        	// featured in the section.
                                                                                                                                                                                                                        	ContentDetails *ChannelSectionContentDetails `json:"contentDetails,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Etag: Etag of this resource.
                                                                                                                                                                                                                        	Etag string `json:"etag,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Id: The ID that YouTube uses to uniquely identify the channel
                                                                                                                                                                                                                        	// section.
                                                                                                                                                                                                                        	Id string `json:"id,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                                                        	// string "youtube#channelSection".
                                                                                                                                                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Localizations: Localizations for different languages
                                                                                                                                                                                                                        	Localizations map[string]ChannelSectionLocalization `json:"localizations,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Snippet: The snippet object contains basic details about the channel
                                                                                                                                                                                                                        	// section, such as its type, style and title.
                                                                                                                                                                                                                        	Snippet *ChannelSectionSnippet `json:"snippet,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Targeting: The targeting object contains basic targeting settings
                                                                                                                                                                                                                        	// about the channel section.
                                                                                                                                                                                                                        	Targeting *ChannelSectionTargeting `json:"targeting,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                        	// server.
                                                                                                                                                                                                                        	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "ContentDetails") to
                                                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "ContentDetails") to
                                                                                                                                                                                                                        	// include in API requests with the JSON null value. By default, fields
                                                                                                                                                                                                                        	// with empty values are omitted from API requests. However, any field
                                                                                                                                                                                                                        	// with an empty value appearing in NullFields will be sent to the
                                                                                                                                                                                                                        	// server as null. It is an error if a field in this list has a
                                                                                                                                                                                                                        	// non-empty value. This may be used to include null fields in Patch
                                                                                                                                                                                                                        	// requests.
                                                                                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                        func (*ChannelSection) MarshalJSON

                                                                                                                                                                                                                        func (s *ChannelSection) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                        type ChannelSectionContentDetails

                                                                                                                                                                                                                        type ChannelSectionContentDetails struct {
                                                                                                                                                                                                                        	// Channels: The channel ids for type multiple_channels.
                                                                                                                                                                                                                        	Channels []string `json:"channels,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// Playlists: The playlist ids for type single_playlist and
                                                                                                                                                                                                                        	// multiple_playlists. For singlePlaylist, only one playlistId is
                                                                                                                                                                                                                        	// allowed.
                                                                                                                                                                                                                        	Playlists []string `json:"playlists,omitempty"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Channels") to
                                                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "Channels") to include in
                                                                                                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          ChannelSectionContentDetails: Details about a channelsection, including playlists and channels.

                                                                                                                                                                                                                          func (*ChannelSectionContentDetails) MarshalJSON

                                                                                                                                                                                                                          func (s *ChannelSectionContentDetails) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                          type ChannelSectionListResponse

                                                                                                                                                                                                                          type ChannelSectionListResponse struct {
                                                                                                                                                                                                                          	// Etag: Etag of this resource.
                                                                                                                                                                                                                          	Etag string `json:"etag,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// EventId: Serialized EventId of the request which produced this
                                                                                                                                                                                                                          	// response.
                                                                                                                                                                                                                          	EventId string `json:"eventId,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// Items: A list of ChannelSections that match the request criteria.
                                                                                                                                                                                                                          	Items []*ChannelSection `json:"items,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                                                          	// string "youtube#channelSectionListResponse".
                                                                                                                                                                                                                          	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// VisitorId: The visitorId identifies the visitor.
                                                                                                                                                                                                                          	VisitorId string `json:"visitorId,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                          	// server.
                                                                                                                                                                                                                          	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Etag") to
                                                                                                                                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// NullFields is a list of field names (e.g. "Etag") to include in API
                                                                                                                                                                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                          	NullFields []string `json:"-"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                          func (*ChannelSectionListResponse) MarshalJSON

                                                                                                                                                                                                                          func (s *ChannelSectionListResponse) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                          type ChannelSectionLocalization

                                                                                                                                                                                                                          type ChannelSectionLocalization struct {
                                                                                                                                                                                                                          	// Title: The localized strings for channel section's title.
                                                                                                                                                                                                                          	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Title") to
                                                                                                                                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// NullFields is a list of field names (e.g. "Title") to include in API
                                                                                                                                                                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                          	NullFields []string `json:"-"`
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            ChannelSectionLocalization: ChannelSection localization setting

                                                                                                                                                                                                                            func (*ChannelSectionLocalization) MarshalJSON

                                                                                                                                                                                                                            func (s *ChannelSectionLocalization) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                            type ChannelSectionSnippet

                                                                                                                                                                                                                            type ChannelSectionSnippet struct {
                                                                                                                                                                                                                            	// ChannelId: The ID that YouTube uses to uniquely identify the channel
                                                                                                                                                                                                                            	// that published the channel section.
                                                                                                                                                                                                                            	ChannelId string `json:"channelId,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// DefaultLanguage: The language of the channel section's default title
                                                                                                                                                                                                                            	// and description.
                                                                                                                                                                                                                            	DefaultLanguage string `json:"defaultLanguage,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Localized: Localized title, read-only.
                                                                                                                                                                                                                            	Localized *ChannelSectionLocalization `json:"localized,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Position: The position of the channel section in the channel.
                                                                                                                                                                                                                            	Position *int64 `json:"position,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Style: The style of the channel section.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// Possible values:
                                                                                                                                                                                                                            	//   "channelsectionStyleUndefined"
                                                                                                                                                                                                                            	//   "horizontalRow"
                                                                                                                                                                                                                            	//   "verticalList"
                                                                                                                                                                                                                            	Style string `json:"style,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Title: The channel section's title for multiple_playlists and
                                                                                                                                                                                                                            	// multiple_channels.
                                                                                                                                                                                                                            	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Type: The type of the channel section.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// Possible values:
                                                                                                                                                                                                                            	//   "allPlaylists"
                                                                                                                                                                                                                            	//   "channelsectionTypeUndefined"
                                                                                                                                                                                                                            	//   "completedEvents"
                                                                                                                                                                                                                            	//   "likedPlaylists"
                                                                                                                                                                                                                            	//   "likes"
                                                                                                                                                                                                                            	//   "liveEvents"
                                                                                                                                                                                                                            	//   "multipleChannels"
                                                                                                                                                                                                                            	//   "multiplePlaylists"
                                                                                                                                                                                                                            	//   "popularUploads"
                                                                                                                                                                                                                            	//   "postedPlaylists"
                                                                                                                                                                                                                            	//   "postedVideos"
                                                                                                                                                                                                                            	//   "recentActivity"
                                                                                                                                                                                                                            	//   "recentPosts"
                                                                                                                                                                                                                            	//   "recentUploads"
                                                                                                                                                                                                                            	//   "singlePlaylist"
                                                                                                                                                                                                                            	//   "subscriptions"
                                                                                                                                                                                                                            	//   "upcomingEvents"
                                                                                                                                                                                                                            	Type string `json:"type,omitempty"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "ChannelId") to
                                                                                                                                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// NullFields is a list of field names (e.g. "ChannelId") to include in
                                                                                                                                                                                                                            	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                            	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                            	NullFields []string `json:"-"`
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              ChannelSectionSnippet: Basic details about a channel section, including title, style and position.

                                                                                                                                                                                                                              func (*ChannelSectionSnippet) MarshalJSON

                                                                                                                                                                                                                              func (s *ChannelSectionSnippet) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                              type ChannelSectionTargeting

                                                                                                                                                                                                                              type ChannelSectionTargeting struct {
                                                                                                                                                                                                                              	// Countries: The country the channel section is targeting.
                                                                                                                                                                                                                              	Countries []string `json:"countries,omitempty"`
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Languages: The language the channel section is targeting.
                                                                                                                                                                                                                              	Languages []string `json:"languages,omitempty"`
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Regions: The region the channel section is targeting.
                                                                                                                                                                                                                              	Regions []string `json:"regions,omitempty"`
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Countries") to
                                                                                                                                                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                              	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                              	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// NullFields is a list of field names (e.g. "Countries") to include in
                                                                                                                                                                                                                              	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                                                              	NullFields []string `json:"-"`
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                ChannelSectionTargeting: ChannelSection targeting setting.

                                                                                                                                                                                                                                func (*ChannelSectionTargeting) MarshalJSON

                                                                                                                                                                                                                                func (s *ChannelSectionTargeting) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                type ChannelSectionsDeleteCall

                                                                                                                                                                                                                                type ChannelSectionsDeleteCall struct {
                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                func (*ChannelSectionsDeleteCall) Context

                                                                                                                                                                                                                                  Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                  func (*ChannelSectionsDeleteCall) Do

                                                                                                                                                                                                                                    Do executes the "youtube.channelSections.delete" call.

                                                                                                                                                                                                                                    func (*ChannelSectionsDeleteCall) Fields

                                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                      func (*ChannelSectionsDeleteCall) Header

                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                        func (*ChannelSectionsDeleteCall) OnBehalfOfContentOwner

                                                                                                                                                                                                                                        func (c *ChannelSectionsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsDeleteCall

                                                                                                                                                                                                                                          OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": Note: This parameter is intended exclusively for YouTube content partners.

                                                                                                                                                                                                                                          The onBehalfOfContentOwner parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.

                                                                                                                                                                                                                                          type ChannelSectionsInsertCall

                                                                                                                                                                                                                                          type ChannelSectionsInsertCall struct {
                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                          func (*ChannelSectionsInsertCall) Context

                                                                                                                                                                                                                                            Context sets the context to be used in this call's Do method. Any pending HTTP request will be aborted if the provided context is canceled.

                                                                                                                                                                                                                                            func (*ChannelSectionsInsertCall) Do

                                                                                                                                                                                                                                              Do executes the "youtube.channelSections.insert" call. Exactly one of *ChannelSection or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ChannelSection.ServerResponse.Header or (if a response was returned at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check whether the returned error was because http.StatusNotModified was returned.

                                                                                                                                                                                                                                              func (*ChannelSectionsInsertCall) Fields

                                                                                                                                                                                                                                                Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                func (*ChannelSectionsInsertCall) Header

                                                                                                                                                                                                                                                  Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                  func (*ChannelSectionsInsertCall) OnBehalfOfContentOwner

                                                                                                                                                                                                                                                  func (c *ChannelSectionsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsInsertCall

                                                                                                                                                                                                                                                    OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner": 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.

                                                                                                                                                                                                                                                    func (*ChannelSectionsInsertCall) OnBehalfOfContentOwnerChannel

                                                                                                                                                                                                                                                    func (c *ChannelSectionsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *ChannelSectionsInsertCall

                                                                                                                                                                                                                                                      OnBehalfOfContentOwnerChannel sets the optional parameter "onBehalfOfContentOwnerChannel": 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.

                                                                                                                                                                                                                                                      type ChannelSectionsListCall

                                                                                                                                                                                                                                                      type ChannelSectionsListCall struct {
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                      func (*ChannelSectionsListCall) ChannelId

                                                                                                                                                                                                                                                      func (c *ChannelSectionsListCall) ChannelId(channelId string) *ChannelSectionsListCall

                                                                                                                                                                                                                                                        ChannelId sets the optional parameter "channelId": The channelId parameter specifies a YouTube channel ID. The API will only return that channel's channelSectio