Documentation

Overview

Package youtube provides access to the YouTube Data API v3.

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

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 AbuseReport

    type AbuseReport struct {
    	AbuseTypes []*AbuseType `json:"abuseTypes,omitempty"`
    
    	Description string `json:"description,omitempty"`
    
    	RelatedEntities []*RelatedEntity `json:"relatedEntities,omitempty"`
    
    	Subject *Entity `json:"subject,omitempty"`
    
    	// ServerResponse contains the HTTP response code and headers from the
    	// server.
    	googleapi.ServerResponse `json:"-"`
    
    	// ForceSendFields is a list of field names (e.g. "AbuseTypes") 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. "AbuseTypes") 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 (*AbuseReport) MarshalJSON

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

    type AbuseReportsInsertCall

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

    func (*AbuseReportsInsertCall) 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 (*AbuseReportsInsertCall) Do

        Do executes the "youtube.abuseReports.insert" call. Exactly one of *AbuseReport or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AbuseReport.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 (*AbuseReportsInsertCall) Fields

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

          func (*AbuseReportsInsertCall) Header

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

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

            type AbuseReportsService

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

            func NewAbuseReportsService

            func NewAbuseReportsService(s *Service) *AbuseReportsService

            func (*AbuseReportsService) Insert

            func (r *AbuseReportsService) Insert(part []string, abusereport *AbuseReport) *AbuseReportsInsertCall

              Insert: Inserts a new resource into this collection.

              type AbuseType

              type AbuseType struct {
              	Id string `json:"id,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Id") 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. "Id") 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 (*AbuseType) MarshalJSON

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

              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 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":

                  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":

                            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":

                                  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":

                                        func (*ActivitiesListCall) PublishedBefore

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

                                          PublishedBefore sets the optional parameter "publishedBefore":

                                          func (*ActivitiesListCall) RegionCode

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

                                            RegionCode sets the optional parameter "regionCode":

                                            type ActivitiesService

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

                                            func NewActivitiesService

                                            func NewActivitiesService(s *Service) *ActivitiesService

                                            func (*ActivitiesService) List

                                            func (r *ActivitiesService) List(part []string) *ActivitiesListCall

                                              List: Retrieves a list of resources, possibly filtered.

                                              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"`
                                              
                                              	// 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. @mutable
                                                  	// youtube.activities.insert
                                                  	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:
                                                              	//   "ctaTypeUnspecified"
                                                              	//   "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:
                                                                	//   "reasonUnspecified"
                                                                	//   "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:
                                                                  	//   "typeUnspecified"
                                                                  	//   "googlePlus"
                                                                  	//   "facebook"
                                                                  	//   "twitter"
                                                                  	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 []*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: General pagination information.
                                                                        	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. @mutable youtube.activities.insert
                                                                        	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.
                                                                        	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:
                                                                        	//   "typeUnspecified"
                                                                        	//   "upload"
                                                                        	//   "like"
                                                                        	//   "favorite"
                                                                        	//   "comment"
                                                                        	//   "subscription"
                                                                        	//   "playlistItem"
                                                                        	//   "recommendation"
                                                                        	//   "bulletin"
                                                                        	//   "social"
                                                                        	//   "channelItem"
                                                                        	//   "promotedItem"
                                                                        	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. Next ID: 12

                                                                          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:
                                                                            	//   "unknown"
                                                                            	//   "primary"
                                                                            	//   "commentary"
                                                                            	//   "descriptive"
                                                                            	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:
                                                                            	//   "unknownFormat"
                                                                            	//   "unsupportedFormat"
                                                                            	//   "processingFailed"
                                                                            	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. @mutable youtube.captions.insert youtube.captions.update
                                                                            	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.
                                                                            	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:
                                                                            	//   "serving"
                                                                            	//   "syncing"
                                                                            	//   "failed"
                                                                            	Status string `json:"status,omitempty"`
                                                                            
                                                                            	// TrackKind: The caption track's type.
                                                                            	//
                                                                            	// Possible values:
                                                                            	//   "standard"
                                                                            	//   "ASR"
                                                                            	//   "forced"
                                                                            	TrackKind string `json:"trackKind,omitempty"`
                                                                            
                                                                            	// VideoId: The ID that YouTube uses to uniquely identify the video
                                                                            	// associated with the caption track. @mutable youtube.captions.insert
                                                                            	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": Convert the captions into this format. Supported options are sbv, srt, and vtt.

                                                                                                            func (*CaptionsDownloadCall) Tlang

                                                                                                              Tlang sets the optional parameter "tlang": tlang is the language code; machine translate the captions into this language.

                                                                                                              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": Extra parameter to allow automatically syncing the uploaded caption/transcript with the audio.

                                                                                                                                  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": Returns the captions with the given IDs for Stubby or Apiary.

                                                                                                                                            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 resource.

                                                                                                                                                    func (*CaptionsService) Download

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

                                                                                                                                                      Download: Downloads a caption track.

                                                                                                                                                      func (*CaptionsService) Insert

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

                                                                                                                                                        Insert: Inserts a new resource into this collection.

                                                                                                                                                        func (*CaptionsService) List

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

                                                                                                                                                          List: Retrieves a list of resources, possibly filtered.

                                                                                                                                                          func (*CaptionsService) Update

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

                                                                                                                                                            Update: Updates an existing resource.

                                                                                                                                                            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 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": Extra parameter to allow automatically syncing the uploaded caption/transcript with the audio.

                                                                                                                                                                                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:
                                                                                                                                                                                	//   "rtmp"
                                                                                                                                                                                	//   "dash"
                                                                                                                                                                                	//   "webrtc"
                                                                                                                                                                                	//   "hls"
                                                                                                                                                                                	IngestionType string `json:"ingestionType,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// Resolution: The resolution of the inbound video data.
                                                                                                                                                                                	//
                                                                                                                                                                                	// Possible values:
                                                                                                                                                                                	//   "240p"
                                                                                                                                                                                	//   "360p"
                                                                                                                                                                                	//   "480p"
                                                                                                                                                                                	//   "720p"
                                                                                                                                                                                	//   "1080p"
                                                                                                                                                                                	//   "1440p"
                                                                                                                                                                                	//   "2160p"
                                                                                                                                                                                	//   "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"`
                                                                                                                                                                                  
                                                                                                                                                                                  	// 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 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": Unused, channel_id is currently derived from the security context of the requestor.

                                                                                                                                                                                          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 actual CMS account that the user authenticates with must be linked to the specified YouTube content owner.

                                                                                                                                                                                                      func (*ChannelBannersInsertCall) OnBehalfOfContentOwnerChannel

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

                                                                                                                                                                                                        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.

                                                                                                                                                                                                        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: Inserts a new resource into this collection.

                                                                                                                                                                                                              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 when the channel was linked to the
                                                                                                                                                                                                                  	// content owner.
                                                                                                                                                                                                                  	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:
                                                                                                                                                                                                                    	//   "subscribe"
                                                                                                                                                                                                                    	//   "unsubscribe"
                                                                                                                                                                                                                    	//   "cview"
                                                                                                                                                                                                                    	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 []*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: General pagination information.
                                                                                                                                                                                                                        	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:
                                                                                                                                                                                                                              	//   "channelsectionStyleUnspecified"
                                                                                                                                                                                                                              	//   "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:
                                                                                                                                                                                                                              	//   "channelsectionTypeUnspecified"
                                                                                                                                                                                                                              	//   "singlePlaylist"
                                                                                                                                                                                                                              	//   "multiplePlaylists"
                                                                                                                                                                                                                              	//   "popularUploads"
                                                                                                                                                                                                                              	//   "recentUploads"
                                                                                                                                                                                                                              	//   "likes"
                                                                                                                                                                                                                              	//   "allPlaylists"
                                                                                                                                                                                                                              	//   "likedPlaylists"
                                                                                                                                                                                                                              	//   "recentPosts"
                                                                                                                                                                                                                              	//   "recentActivity"
                                                                                                                                                                                                                              	//   "liveEvents"
                                                                                                                                                                                                                              	//   "upcomingEvents"
                                                                                                                                                                                                                              	//   "completedEvents"
                                                                                                                                                                                                                              	//   "multipleChannels"
                                                                                                                                                                                                                              	//   "postedVideos"
                                                                                                                                                                                                                              	//   "postedPlaylists"
                                                                                                                                                                                                                              	//   "subscriptions"
                                                                                                                                                                                                                              	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": Return the ChannelSections owned by the specified channel ID.

                                                                                                                                                                                                                                                          func (*ChannelSectionsListCall) 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 (*ChannelSectionsListCall) Do

                                                                                                                                                                                                                                                              Do executes the "youtube.channelSections.list" call. Exactly one of *ChannelSectionListResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ChannelSectionListResponse.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 (*ChannelSectionsListCall) Fields

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

                                                                                                                                                                                                                                                                func (*ChannelSectionsListCall) Header

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

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

                                                                                                                                                                                                                                                                  func (*ChannelSectionsListCall) Hl

                                                                                                                                                                                                                                                                    Hl sets the optional parameter "hl": Return content in specified language

                                                                                                                                                                                                                                                                    func (*ChannelSectionsListCall) Id

                                                                                                                                                                                                                                                                      Id sets the optional parameter "id": Return the ChannelSections with the given IDs for Stubby or Apiary.

                                                                                                                                                                                                                                                                      func (*ChannelSectionsListCall) IfNoneMatch

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

                                                                                                                                                                                                                                                                        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 (*ChannelSectionsListCall) Mine

                                                                                                                                                                                                                                                                          Mine sets the optional parameter "mine": Return the ChannelSections owned by the authenticated user.

                                                                                                                                                                                                                                                                          func (*ChannelSectionsListCall) OnBehalfOfContentOwner

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

                                                                                                                                                                                                                                                                            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 ChannelSectionsService

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

                                                                                                                                                                                                                                                                            func NewChannelSectionsService

                                                                                                                                                                                                                                                                            func NewChannelSectionsService(s *Service) *ChannelSectionsService

                                                                                                                                                                                                                                                                            func (*ChannelSectionsService) Delete

                                                                                                                                                                                                                                                                              Delete: Deletes a resource.

                                                                                                                                                                                                                                                                              func (*ChannelSectionsService) Insert

                                                                                                                                                                                                                                                                              func (r *ChannelSectionsService) Insert(part []string, channelsection *ChannelSection) *ChannelSectionsInsertCall

                                                                                                                                                                                                                                                                                Insert: Inserts a new resource into this collection.

                                                                                                                                                                                                                                                                                func (*ChannelSectionsService) List

                                                                                                                                                                                                                                                                                  List: Retrieves a list of resources, possibly filtered.

                                                                                                                                                                                                                                                                                  func (*ChannelSectionsService) Update

                                                                                                                                                                                                                                                                                  func (r *ChannelSectionsService) Update(part []string, channelsection *ChannelSection) *ChannelSectionsUpdateCall

                                                                                                                                                                                                                                                                                    Update: Updates an existing resource.

                                                                                                                                                                                                                                                                                    type ChannelSectionsUpdateCall

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

                                                                                                                                                                                                                                                                                    func (*ChannelSectionsUpdateCall) 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 (*ChannelSectionsUpdateCall) Do

                                                                                                                                                                                                                                                                                        Do executes the "youtube.channelSections.update" 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 (*ChannelSectionsUpdateCall) Fields

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

                                                                                                                                                                                                                                                                                          func (*ChannelSectionsUpdateCall) Header

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

                                                                                                                                                                                                                                                                                            func (*ChannelSectionsUpdateCall) OnBehalfOfContentOwner

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

                                                                                                                                                                                                                                                                                              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 ChannelSettings

                                                                                                                                                                                                                                                                                              type ChannelSettings struct {
                                                                                                                                                                                                                                                                                              	// Country: The country of the channel.
                                                                                                                                                                                                                                                                                              	Country string `json:"country,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	DefaultLanguage string `json:"defaultLanguage,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// DefaultTab: Which content tab users should see when viewing the
                                                                                                                                                                                                                                                                                              	// channel.
                                                                                                                                                                                                                                                                                              	DefaultTab string `json:"defaultTab,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// Description: Specifies the channel description.
                                                                                                                                                                                                                                                                                              	Description string `json:"description,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// FeaturedChannelsTitle: Title for the featured channels tab.
                                                                                                                                                                                                                                                                                              	FeaturedChannelsTitle string `json:"featuredChannelsTitle,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// FeaturedChannelsUrls: The list of featured channels.
                                                                                                                                                                                                                                                                                              	FeaturedChannelsUrls []string `json:"featuredChannelsUrls,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// Keywords: Lists keywords associated with the channel,
                                                                                                                                                                                                                                                                                              	// comma-separated.
                                                                                                                                                                                                                                                                                              	Keywords string `json:"keywords,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ModerateComments: Whether user-submitted comments left on the channel
                                                                                                                                                                                                                                                                                              	// page need to be approved by the channel owner to be publicly visible.
                                                                                                                                                                                                                                                                                              	ModerateComments bool `json:"moderateComments,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ProfileColor: A prominent color that can be rendered on this channel
                                                                                                                                                                                                                                                                                              	// page.
                                                                                                                                                                                                                                                                                              	ProfileColor string `json:"profileColor,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ShowBrowseView: Whether the tab to browse the videos should be
                                                                                                                                                                                                                                                                                              	// displayed.
                                                                                                                                                                                                                                                                                              	ShowBrowseView bool `json:"showBrowseView,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ShowRelatedChannels: Whether related channels should be proposed.
                                                                                                                                                                                                                                                                                              	ShowRelatedChannels bool `json:"showRelatedChannels,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// Title: Specifies the channel title.
                                                                                                                                                                                                                                                                                              	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// TrackingAnalyticsAccountId: The ID for a Google Analytics account to
                                                                                                                                                                                                                                                                                              	// track and measure traffic to the channels.
                                                                                                                                                                                                                                                                                              	TrackingAnalyticsAccountId string `json:"trackingAnalyticsAccountId,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// UnsubscribedTrailer: The trailer of the channel, for users that are
                                                                                                                                                                                                                                                                                              	// not subscribers.
                                                                                                                                                                                                                                                                                              	UnsubscribedTrailer string `json:"unsubscribedTrailer,omitempty"`
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "Country") 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. "Country") 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:"-"`
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                ChannelSettings: Branding properties for the channel view.

                                                                                                                                                                                                                                                                                                func (*ChannelSettings) MarshalJSON

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

                                                                                                                                                                                                                                                                                                type ChannelSnippet

                                                                                                                                                                                                                                                                                                type ChannelSnippet struct {
                                                                                                                                                                                                                                                                                                	// Country: The country of the channel.
                                                                                                                                                                                                                                                                                                	Country string `json:"country,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// CustomUrl: The custom url of the channel.
                                                                                                                                                                                                                                                                                                	CustomUrl string `json:"customUrl,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// DefaultLanguage: The language of the channel's default title and
                                                                                                                                                                                                                                                                                                	// description.
                                                                                                                                                                                                                                                                                                	DefaultLanguage string `json:"defaultLanguage,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// Description: The description of the channel.
                                                                                                                                                                                                                                                                                                	Description string `json:"description,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// Localized: Localized title and description, read-only.
                                                                                                                                                                                                                                                                                                	Localized *ChannelLocalization `json:"localized,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// PublishedAt: The date and time that the channel was created.
                                                                                                                                                                                                                                                                                                	PublishedAt string `json:"publishedAt,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// Thumbnails: A map of thumbnail images associated with the channel.
                                                                                                                                                                                                                                                                                                	// 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. When displaying thumbnails in your application,
                                                                                                                                                                                                                                                                                                	// make sure that your code uses the image URLs exactly as they are
                                                                                                                                                                                                                                                                                                	// returned in API responses. For example, your application should not
                                                                                                                                                                                                                                                                                                	// use the http domain instead of the https domain in a URL returned in
                                                                                                                                                                                                                                                                                                	// an API response. Beginning in July 2018, channel thumbnail URLs will
                                                                                                                                                                                                                                                                                                	// only be available in the https domain, which is how the URLs appear
                                                                                                                                                                                                                                                                                                	// in API responses. After that time, you might see broken images in
                                                                                                                                                                                                                                                                                                	// your application if it tries to load YouTube images from the http
                                                                                                                                                                                                                                                                                                	// domain. Thumbnail images might be empty for newly created channels
                                                                                                                                                                                                                                                                                                	// and might take up to one day to populate.
                                                                                                                                                                                                                                                                                                	Thumbnails *ThumbnailDetails `json:"thumbnails,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// Title: The channel's title.
                                                                                                                                                                                                                                                                                                	Title string `json:"title,omitempty"`
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Country") 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. "Country") 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:"-"`
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  ChannelSnippet: Basic details about a channel, including title, description and thumbnails.

                                                                                                                                                                                                                                                                                                  func (*ChannelSnippet) MarshalJSON

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

                                                                                                                                                                                                                                                                                                  type ChannelStatistics

                                                                                                                                                                                                                                                                                                  type ChannelStatistics struct {
                                                                                                                                                                                                                                                                                                  	// CommentCount: The number of comments for the channel.
                                                                                                                                                                                                                                                                                                  	CommentCount uint64 `json:"commentCount,omitempty,string"`
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// HiddenSubscriberCount: Whether or not the number of subscribers is
                                                                                                                                                                                                                                                                                                  	// shown for this user.
                                                                                                                                                                                                                                                                                                  	HiddenSubscriberCount bool `json:"hiddenSubscriberCount,omitempty"`
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// SubscriberCount: The number of subscribers that the channel has.
                                                                                                                                                                                                                                                                                                  	SubscriberCount uint64 `json:"subscriberCount,omitempty,string"`
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// VideoCount: The number of videos uploaded to the channel.
                                                                                                                                                                                                                                                                                                  	VideoCount uint64 `json:"videoCount,omitempty,string"`
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// ViewCount: The number of times the channel has been viewed.
                                                                                                                                                                                                                                                                                                  	ViewCount uint64 `json:"viewCount,omitempty,string"`
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "CommentCount") 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. "CommentCount") 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:"-"`
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    ChannelStatistics: Statistics about a channel: number of subscribers, number of videos in the channel, etc.

                                                                                                                                                                                                                                                                                                    func (*ChannelStatistics) MarshalJSON

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

                                                                                                                                                                                                                                                                                                    type ChannelStatus

                                                                                                                                                                                                                                                                                                    type ChannelStatus struct {
                                                                                                                                                                                                                                                                                                    	// IsLinked: If true, then the user is linked to either a YouTube
                                                                                                                                                                                                                                                                                                    	// username or G+ account. Otherwise, the user doesn't have a public
                                                                                                                                                                                                                                                                                                    	// YouTube identity.
                                                                                                                                                                                                                                                                                                    	IsLinked bool `json:"isLinked,omitempty"`
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// LongUploadsStatus: The long uploads status of this channel. See
                                                                                                                                                                                                                                                                                                    	// https://support.google.com/youtube/answer/71673 for more information.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// Possible values:
                                                                                                                                                                                                                                                                                                    	//   "longUploadsUnspecified"
                                                                                                                                                                                                                                                                                                    	//   "allowed"
                                                                                                                                                                                                                                                                                                    	//   "eligible"
                                                                                                                                                                                                                                                                                                    	//   "disallowed"
                                                                                                                                                                                                                                                                                                    	LongUploadsStatus string `json:"longUploadsStatus,omitempty"`
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	MadeForKids bool `json:"madeForKids,omitempty"`
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// PrivacyStatus: Privacy status of the channel.
                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                    	// Possible values:
                                                                                                                                                                                                                                                                                                    	//   "public"
                                                                                                                                                                                                                                                                                                    	//   "unlisted"
                                                                                                                                                                                                                                                                                                    	//   "private"
                                                                                                                                                                                                                                                                                                    	PrivacyStatus string `json:"privacyStatus,omitempty"`
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	SelfDeclaredMadeForKids bool `json:"selfDeclaredMadeForKids,omitempty"`
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// ForceSendFields is a list of field names (e.g. "IsLinked") 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. "IsLinked") 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:"-"`
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      ChannelStatus: JSON template for the status part of a channel.

                                                                                                                                                                                                                                                                                                      func (*ChannelStatus) MarshalJSON

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

                                                                                                                                                                                                                                                                                                      type ChannelToStoreLinkDetails

                                                                                                                                                                                                                                                                                                      type ChannelToStoreLinkDetails struct {
                                                                                                                                                                                                                                                                                                      	// StoreName: Name of the store.
                                                                                                                                                                                                                                                                                                      	StoreName string `json:"storeName,omitempty"`
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// StoreUrl: Landing page of the store.
                                                                                                                                                                                                                                                                                                      	StoreUrl string `json:"storeUrl,omitempty"`
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "StoreName") 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. "StoreName") 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:"-"`
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        ChannelToStoreLinkDetails: Information specific to a store on a merchandising platform linked to a YouTube channel.

                                                                                                                                                                                                                                                                                                        func (*ChannelToStoreLinkDetails) MarshalJSON

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

                                                                                                                                                                                                                                                                                                        type ChannelTopicDetails

                                                                                                                                                                                                                                                                                                        type ChannelTopicDetails struct {
                                                                                                                                                                                                                                                                                                        	// TopicCategories: A list of Wikipedia URLs that describe the channel's
                                                                                                                                                                                                                                                                                                        	// content.
                                                                                                                                                                                                                                                                                                        	TopicCategories []string `json:"topicCategories,omitempty"`
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// TopicIds: A list of Freebase topic IDs associated with the channel.
                                                                                                                                                                                                                                                                                                        	// You can retrieve information about each topic using the Freebase
                                                                                                                                                                                                                                                                                                        	// Topic API.
                                                                                                                                                                                                                                                                                                        	TopicIds []string `json:"topicIds,omitempty"`
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "TopicCategories") 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. "TopicCategories") 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:"-"`
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          ChannelTopicDetails: Freebase topic information related to the channel.

                                                                                                                                                                                                                                                                                                          func (*ChannelTopicDetails) MarshalJSON

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

                                                                                                                                                                                                                                                                                                          type ChannelsListCall

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

                                                                                                                                                                                                                                                                                                          func (*ChannelsListCall) CategoryId

                                                                                                                                                                                                                                                                                                          func (c *ChannelsListCall) CategoryId(categoryId string) *ChannelsListCall

                                                                                                                                                                                                                                                                                                            CategoryId sets the optional parameter "categoryId": Return the channels within the specified guide category ID.

                                                                                                                                                                                                                                                                                                            func (*ChannelsListCall) 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 (*ChannelsListCall) Do

                                                                                                                                                                                                                                                                                                                Do executes the "youtube.channels.list" call. Exactly one of *ChannelListResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ChannelListResponse.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 (*ChannelsListCall) Fields

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

                                                                                                                                                                                                                                                                                                                  func (*ChannelsListCall) ForUsername

                                                                                                                                                                                                                                                                                                                  func (c *ChannelsListCall) ForUsername(forUsername string) *ChannelsListCall

                                                                                                                                                                                                                                                                                                                    ForUsername sets the optional parameter "forUsername": Return the channel associated with a YouTube username.

                                                                                                                                                                                                                                                                                                                    func (*ChannelsListCall) Header

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

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

                                                                                                                                                                                                                                                                                                                      func (*ChannelsListCall) Hl

                                                                                                                                                                                                                                                                                                                        Hl sets the optional parameter "hl": Stands for "host language". Specifies the localization language of the metadata to be filled into snippet.localized. The field is filled with the default metadata if there is no localization in the specified language. The parameter value must be a language code included in the list returned by the i18nLanguages.list method (e.g. en_US, es_MX).

                                                                                                                                                                                                                                                                                                                        func (*ChannelsListCall) Id

                                                                                                                                                                                                                                                                                                                          Id sets the optional parameter "id": Return the channels with the specified IDs.

                                                                                                                                                                                                                                                                                                                          func (*ChannelsListCall) IfNoneMatch

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

                                                                                                                                                                                                                                                                                                                            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 (*ChannelsListCall) ManagedByMe

                                                                                                                                                                                                                                                                                                                            func (c *ChannelsListCall) ManagedByMe(managedByMe bool) *ChannelsListCall

                                                                                                                                                                                                                                                                                                                              ManagedByMe sets the optional parameter "managedByMe": Return the channels managed by the authenticated user.

                                                                                                                                                                                                                                                                                                                              func (*ChannelsListCall) MaxResults

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

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

                                                                                                                                                                                                                                                                                                                                func (*ChannelsListCall) Mine

                                                                                                                                                                                                                                                                                                                                func (c *ChannelsListCall) Mine(mine bool) *ChannelsListCall

                                                                                                                                                                                                                                                                                                                                  Mine sets the optional parameter "mine": Return the ids of channels owned by the authenticated user.

                                                                                                                                                                                                                                                                                                                                  func (*ChannelsListCall) MySubscribers

                                                                                                                                                                                                                                                                                                                                  func (c *ChannelsListCall) MySubscribers(mySubscribers bool) *ChannelsListCall

                                                                                                                                                                                                                                                                                                                                    MySubscribers sets the optional parameter "mySubscribers": Return the channels subscribed to the authenticated user

                                                                                                                                                                                                                                                                                                                                    func (*ChannelsListCall) OnBehalfOfContentOwner

                                                                                                                                                                                                                                                                                                                                    func (c *ChannelsListCall) OnBeha