youtube/v3/youtube-gen.go

// Copyright 2026 Google LLC.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Code generated file. DO NOT EDIT.

// Package youtube provides access to the YouTube Data API v3.
//
// For product documentation, see: https://developers.google.com/youtube/
//
// # Library status
//
// These client libraries are officially supported by Google. However, this
// library is considered complete and is in maintenance mode. This means
// that we will address critical bugs and security issues but will not add
// any new features.
//
// When possible, we recommend using our newer
// [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go)
// that are still actively being worked and iterated on.
//
// # 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 [google.golang.org/api/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 [google.golang.org/api/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 [google.golang.org/api/option.WithTokenSource]:
//
//	config := &oauth2.Config{...}
//	// ...
//	token, err := config.Exchange(ctx, ...)
//	youtubeService, err := youtube.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
//
// See [google.golang.org/api/option.ClientOption] for details on options.
package youtube // import "google.golang.org/api/youtube/v3"

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	"github.com/googleapis/gax-go/v2/internallog"
	googleapi "google.golang.org/api/googleapi"
	internal "google.golang.org/api/internal"
	gensupport "google.golang.org/api/internal/gensupport"
	option "google.golang.org/api/option"
	internaloption "google.golang.org/api/option/internaloption"
	htransport "google.golang.org/api/transport/http"
)

// Always reference these packages, just in case the auto-generated code
// below doesn't.
var _ = bytes.NewBuffer
var _ = strconv.Itoa
var _ = fmt.Sprintf
var _ = json.NewDecoder
var _ = io.Copy
var _ = url.Parse
var _ = gensupport.MarshalJSON
var _ = googleapi.Version
var _ = errors.New
var _ = strings.Replace
var _ = context.Canceled
var _ = internaloption.WithDefaultEndpoint
var _ = internal.Version
var _ = internallog.New

const apiId = "youtube:v3"
const apiName = "youtube"
const apiVersion = "v3"
const basePath = "https://youtube.googleapis.com/"
const basePathTemplate = "https://youtube.UNIVERSE_DOMAIN/"
const mtlsBasePath = "https://youtube.mtls.googleapis.com/"

// OAuth2 scopes used by this API.
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"
)

// NewService creates a new Service.
func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
	scopesOption := internaloption.WithDefaultScopes(
		"https://www.googleapis.com/auth/youtube",
		"https://www.googleapis.com/auth/youtube.channel-memberships.creator",
		"https://www.googleapis.com/auth/youtube.force-ssl",
		"https://www.googleapis.com/auth/youtube.readonly",
		"https://www.googleapis.com/auth/youtube.upload",
		"https://www.googleapis.com/auth/youtubepartner",
		"https://www.googleapis.com/auth/youtubepartner-channel-audit",
	)
	// NOTE: prepend, so we don't override user-specified scopes.
	opts = append([]option.ClientOption{scopesOption}, opts...)
	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
	opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
	opts = append(opts, internaloption.EnableNewAuthLibrary())
	client, endpoint, err := htransport.NewClient(ctx, opts...)
	if err != nil {
		return nil, err
	}
	s := &Service{client: client, BasePath: basePath, logger: internaloption.GetLogger(opts)}
	s.AbuseReports = NewAbuseReportsService(s)
	s.Activities = NewActivitiesService(s)
	s.Captions = NewCaptionsService(s)
	s.ChannelBanners = NewChannelBannersService(s)
	s.ChannelSections = NewChannelSectionsService(s)
	s.Channels = NewChannelsService(s)
	s.CommentThreads = NewCommentThreadsService(s)
	s.Comments = NewCommentsService(s)
	s.I18nLanguages = NewI18nLanguagesService(s)
	s.I18nRegions = NewI18nRegionsService(s)
	s.LiveBroadcasts = NewLiveBroadcastsService(s)
	s.LiveChatBans = NewLiveChatBansService(s)
	s.LiveChatMessages = NewLiveChatMessagesService(s)
	s.LiveChatModerators = NewLiveChatModeratorsService(s)
	s.LiveStreams = NewLiveStreamsService(s)
	s.Members = NewMembersService(s)
	s.MembershipsLevels = NewMembershipsLevelsService(s)
	s.PlaylistImages = NewPlaylistImagesService(s)
	s.PlaylistItems = NewPlaylistItemsService(s)
	s.Playlists = NewPlaylistsService(s)
	s.Search = NewSearchService(s)
	s.Subscriptions = NewSubscriptionsService(s)
	s.SuperChatEvents = NewSuperChatEventsService(s)
	s.Tests = NewTestsService(s)
	s.ThirdPartyLinks = NewThirdPartyLinksService(s)
	s.Thumbnails = NewThumbnailsService(s)
	s.VideoAbuseReportReasons = NewVideoAbuseReportReasonsService(s)
	s.VideoCategories = NewVideoCategoriesService(s)
	s.VideoTrainability = NewVideoTrainabilityService(s)
	s.Videos = NewVideosService(s)
	s.Watermarks = NewWatermarksService(s)
	s.Youtube = NewYoutubeService(s)
	if endpoint != "" {
		s.BasePath = endpoint
	}
	return s, nil
}

// New creates a new Service. It uses the provided http.Client for requests.
//
// Deprecated: please use NewService instead.
// To provide a custom HTTP client, use option.WithHTTPClient.
// If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.
func New(client *http.Client) (*Service, error) {
	if client == nil {
		return nil, errors.New("client is nil")
	}
	return NewService(context.TODO(), option.WithHTTPClient(client))
}

type Service struct {
	client    *http.Client
	logger    *slog.Logger
	BasePath  string // API endpoint base URL
	UserAgent string // optional additional User-Agent fragment

	AbuseReports *AbuseReportsService

	Activities *ActivitiesService

	Captions *CaptionsService

	ChannelBanners *ChannelBannersService

	ChannelSections *ChannelSectionsService

	Channels *ChannelsService

	CommentThreads *CommentThreadsService

	Comments *CommentsService

	I18nLanguages *I18nLanguagesService

	I18nRegions *I18nRegionsService

	LiveBroadcasts *LiveBroadcastsService

	LiveChatBans *LiveChatBansService

	LiveChatMessages *LiveChatMessagesService

	LiveChatModerators *LiveChatModeratorsService

	LiveStreams *LiveStreamsService

	Members *MembersService

	MembershipsLevels *MembershipsLevelsService

	PlaylistImages *PlaylistImagesService

	PlaylistItems *PlaylistItemsService

	Playlists *PlaylistsService

	Search *SearchService

	Subscriptions *SubscriptionsService

	SuperChatEvents *SuperChatEventsService

	Tests *TestsService

	ThirdPartyLinks *ThirdPartyLinksService

	Thumbnails *ThumbnailsService

	VideoAbuseReportReasons *VideoAbuseReportReasonsService

	VideoCategories *VideoCategoriesService

	VideoTrainability *VideoTrainabilityService

	Videos *VideosService

	Watermarks *WatermarksService

	Youtube *YoutubeService
}

func (s *Service) userAgent() string {
	if s.UserAgent == "" {
		return googleapi.UserAgent
	}
	return googleapi.UserAgent + " " + s.UserAgent
}

func NewAbuseReportsService(s *Service) *AbuseReportsService {
	rs := &AbuseReportsService{s: s}
	return rs
}

type AbuseReportsService struct {
	s *Service
}

func NewActivitiesService(s *Service) *ActivitiesService {
	rs := &ActivitiesService{s: s}
	return rs
}

type ActivitiesService struct {
	s *Service
}

func NewCaptionsService(s *Service) *CaptionsService {
	rs := &CaptionsService{s: s}
	return rs
}

type CaptionsService struct {
	s *Service
}

func NewChannelBannersService(s *Service) *ChannelBannersService {
	rs := &ChannelBannersService{s: s}
	return rs
}

type ChannelBannersService struct {
	s *Service
}

func NewChannelSectionsService(s *Service) *ChannelSectionsService {
	rs := &ChannelSectionsService{s: s}
	return rs
}

type ChannelSectionsService struct {
	s *Service
}

func NewChannelsService(s *Service) *ChannelsService {
	rs := &ChannelsService{s: s}
	return rs
}

type ChannelsService struct {
	s *Service
}

func NewCommentThreadsService(s *Service) *CommentThreadsService {
	rs := &CommentThreadsService{s: s}
	return rs
}

type CommentThreadsService struct {
	s *Service
}

func NewCommentsService(s *Service) *CommentsService {
	rs := &CommentsService{s: s}
	return rs
}

type CommentsService struct {
	s *Service
}

func NewI18nLanguagesService(s *Service) *I18nLanguagesService {
	rs := &I18nLanguagesService{s: s}
	return rs
}

type I18nLanguagesService struct {
	s *Service
}

func NewI18nRegionsService(s *Service) *I18nRegionsService {
	rs := &I18nRegionsService{s: s}
	return rs
}

type I18nRegionsService struct {
	s *Service
}

func NewLiveBroadcastsService(s *Service) *LiveBroadcastsService {
	rs := &LiveBroadcastsService{s: s}
	return rs
}

type LiveBroadcastsService struct {
	s *Service
}

func NewLiveChatBansService(s *Service) *LiveChatBansService {
	rs := &LiveChatBansService{s: s}
	return rs
}

type LiveChatBansService struct {
	s *Service
}

func NewLiveChatMessagesService(s *Service) *LiveChatMessagesService {
	rs := &LiveChatMessagesService{s: s}
	return rs
}

type LiveChatMessagesService struct {
	s *Service
}

func NewLiveChatModeratorsService(s *Service) *LiveChatModeratorsService {
	rs := &LiveChatModeratorsService{s: s}
	return rs
}

type LiveChatModeratorsService struct {
	s *Service
}

func NewLiveStreamsService(s *Service) *LiveStreamsService {
	rs := &LiveStreamsService{s: s}
	return rs
}

type LiveStreamsService struct {
	s *Service
}

func NewMembersService(s *Service) *MembersService {
	rs := &MembersService{s: s}
	return rs
}

type MembersService struct {
	s *Service
}

func NewMembershipsLevelsService(s *Service) *MembershipsLevelsService {
	rs := &MembershipsLevelsService{s: s}
	return rs
}

type MembershipsLevelsService struct {
	s *Service
}

func NewPlaylistImagesService(s *Service) *PlaylistImagesService {
	rs := &PlaylistImagesService{s: s}
	return rs
}

type PlaylistImagesService struct {
	s *Service
}

func NewPlaylistItemsService(s *Service) *PlaylistItemsService {
	rs := &PlaylistItemsService{s: s}
	return rs
}

type PlaylistItemsService struct {
	s *Service
}

func NewPlaylistsService(s *Service) *PlaylistsService {
	rs := &PlaylistsService{s: s}
	return rs
}

type PlaylistsService struct {
	s *Service
}

func NewSearchService(s *Service) *SearchService {
	rs := &SearchService{s: s}
	return rs
}

type SearchService struct {
	s *Service
}

func NewSubscriptionsService(s *Service) *SubscriptionsService {
	rs := &SubscriptionsService{s: s}
	return rs
}

type SubscriptionsService struct {
	s *Service
}

func NewSuperChatEventsService(s *Service) *SuperChatEventsService {
	rs := &SuperChatEventsService{s: s}
	return rs
}

type SuperChatEventsService struct {
	s *Service
}

func NewTestsService(s *Service) *TestsService {
	rs := &TestsService{s: s}
	return rs
}

type TestsService struct {
	s *Service
}

func NewThirdPartyLinksService(s *Service) *ThirdPartyLinksService {
	rs := &ThirdPartyLinksService{s: s}
	return rs
}

type ThirdPartyLinksService struct {
	s *Service
}

func NewThumbnailsService(s *Service) *ThumbnailsService {
	rs := &ThumbnailsService{s: s}
	return rs
}

type ThumbnailsService struct {
	s *Service
}

func NewVideoAbuseReportReasonsService(s *Service) *VideoAbuseReportReasonsService {
	rs := &VideoAbuseReportReasonsService{s: s}
	return rs
}

type VideoAbuseReportReasonsService struct {
	s *Service
}

func NewVideoCategoriesService(s *Service) *VideoCategoriesService {
	rs := &VideoCategoriesService{s: s}
	return rs
}

type VideoCategoriesService struct {
	s *Service
}

func NewVideoTrainabilityService(s *Service) *VideoTrainabilityService {
	rs := &VideoTrainabilityService{s: s}
	return rs
}

type VideoTrainabilityService struct {
	s *Service
}

func NewVideosService(s *Service) *VideosService {
	rs := &VideosService{s: s}
	return rs
}

type VideosService struct {
	s *Service
}

func NewWatermarksService(s *Service) *WatermarksService {
	rs := &WatermarksService{s: s}
	return rs
}

type WatermarksService struct {
	s *Service
}

func NewYoutubeService(s *Service) *YoutubeService {
	rs := &YoutubeService{s: s}
	rs.V3 = NewYoutubeV3Service(s)
	return rs
}

type YoutubeService struct {
	s *Service

	V3 *YoutubeV3Service
}

func NewYoutubeV3Service(s *Service) *YoutubeV3Service {
	rs := &YoutubeV3Service{s: s}
	rs.LiveChat = NewYoutubeV3LiveChatService(s)
	return rs
}

type YoutubeV3Service struct {
	s *Service

	LiveChat *YoutubeV3LiveChatService
}

func NewYoutubeV3LiveChatService(s *Service) *YoutubeV3LiveChatService {
	rs := &YoutubeV3LiveChatService{s: s}
	rs.Messages = NewYoutubeV3LiveChatMessagesService(s)
	return rs
}

type YoutubeV3LiveChatService struct {
	s *Service

	Messages *YoutubeV3LiveChatMessagesService
}

func NewYoutubeV3LiveChatMessagesService(s *Service) *YoutubeV3LiveChatMessagesService {
	rs := &YoutubeV3LiveChatMessagesService{s: s}
	return rs
}

type YoutubeV3LiveChatMessagesService struct {
	s *Service
}

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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AbuseReport) MarshalJSON() ([]byte, error) {
	type NoMethod AbuseReport
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AbuseType) MarshalJSON() ([]byte, error) {
	type NoMethod AbuseType
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AccessPolicy: Rights management policy for YouTube resources.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AccessPolicy) MarshalJSON() ([]byte, error) {
	type NoMethod AccessPolicy
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// 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 sharing 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.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Activity) MarshalJSON() ([]byte, error) {
	type NoMethod Activity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetails: Details about the content of an activity: the video
// that was shared, the channel that was subscribed to, etc.
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"`
	// 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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsBulletin: Details about a channel bulletin post.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsBulletin) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsBulletin
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsChannelItem: Details about a resource which was added
// to a channel.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsChannelItem) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsChannelItem
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsComment: Information about a resource that received a
// comment.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsComment) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsComment
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsPlaylistItem: Information about a new playlist item.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsPlaylistItem) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsPlaylistItem
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsPromotedItem: Details about a resource which is being
// promoted.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsPromotedItem) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsPromotedItem
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsRecommendation: Information that identifies the
// recommended resource.
type ActivityContentDetailsRecommendation struct {
	// Reason: The reason that the resource is recommended to the user.
	//
	// Possible values:
	//   "reasonUnspecified"
	//   "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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsRecommendation) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsRecommendation
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsSocial: Details about a social network post.
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:
	//   "unspecified"
	//   "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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsSocial) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsSocial
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsSubscription: Information about a channel that a user
// subscribed to.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsSubscription) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsSubscription
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivityContentDetailsUpload: Information about the uploaded video.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityContentDetailsUpload) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityContentDetailsUpload
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivityListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ActivityListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ActivitySnippet: Basic details about an activity, including title,
// description, thumbnails, activity type and group. Next ID: 12
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 uploads a video and watches the same video, 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"
	//   "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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ActivitySnippet) MarshalJSON() ([]byte, error) {
	type NoMethod ActivitySnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AvailabilityConfig: Common proto for Live and VOD geo-restrictions
type AvailabilityConfig struct {
	// GlobalConfig: Video is available in all regions except the ones specified in
	// the config.
	GlobalConfig *AvailabilityConfigGlobalConfig `json:"globalConfig,omitempty"`
	// RegionsConfig: Video is available in the specified regions only.
	RegionsConfig *AvailabilityConfigRegionsConfig `json:"regionsConfig,omitempty"`
	// ForceSendFields is a list of field names (e.g. "GlobalConfig") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GlobalConfig") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AvailabilityConfig) MarshalJSON() ([]byte, error) {
	type NoMethod AvailabilityConfig
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AvailabilityConfigGlobalConfig: Video is available in all regions except the
// ones specified in the excluded_region_codes list.
type AvailabilityConfigGlobalConfig struct {
	// ExcludedRegionCodes: Optional. Regions where video is blocked
	ExcludedRegionCodes []string `json:"excludedRegionCodes,omitempty"`
	// Interval: Default time window where video is available for all non-blocked
	// regions Not supported for upcoming / active live broadcasts. If start time
	// is unspecified, video is already available If end time is unspecified, video
	// is available forever Specified start and end times cannot be more than five
	// years in the future.
	Interval *Interval `json:"interval,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ExcludedRegionCodes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ExcludedRegionCodes") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AvailabilityConfigGlobalConfig) MarshalJSON() ([]byte, error) {
	type NoMethod AvailabilityConfigGlobalConfig
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AvailabilityConfigRegionsConfig: Video is available in the specified regions
// only.
type AvailabilityConfigRegionsConfig struct {
	// RegionIntervals: Required. List of regions and time windows where video is
	// available. If a region is specified multiple times, the union of all
	// intervals is used.
	RegionIntervals []*AvailabilityConfigRegionsConfigRegionInterval `json:"regionIntervals,omitempty"`
	// ForceSendFields is a list of field names (e.g. "RegionIntervals") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RegionIntervals") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AvailabilityConfigRegionsConfig) MarshalJSON() ([]byte, error) {
	type NoMethod AvailabilityConfigRegionsConfig
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// AvailabilityConfigRegionsConfigRegionInterval: Region and time window where
// video is available for the region.
type AvailabilityConfigRegionsConfigRegionInterval struct {
	// Interval: Time window where video is available for the region. Not supported
	// for upcoming / active live broadcasts. If start time is unspecified, video
	// is already available If end time is unspecified, video is available forever
	// Specified start and end times cannot be more than five years in the future.
	Interval *Interval `json:"interval,omitempty"`
	// RegionCode: Required. Region where video is available
	RegionCode string `json:"regionCode,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Interval") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Interval") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s AvailabilityConfigRegionsConfigRegionInterval) MarshalJSON() ([]byte, error) {
	type NoMethod AvailabilityConfigRegionsConfigRegionInterval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// BatchGetStatsResponse: Response for the Videos.stats API. Returns VideoStat
// information about a batch of videos. VideoStat contains a subset of the
// information in Video that is relevant to statistics and content details.
// BatchGetStats is intentionally not atomic to provide a better user
// experience. BatchGetStatsResponse returns a summary to help users understand
// the outcome of the operation.
type BatchGetStatsResponse struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Items: The videos' stats information.
	Items []*VideoStat `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#batchGetStatsResponse".
	Kind string `json:"kind,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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BatchGetStatsResponse) MarshalJSON() ([]byte, error) {
	type NoMethod BatchGetStatsResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// BrandPartner: Details about the brand partner linked to the video for
// Creator Initiated Linking (CIL). Next ID: 6
type BrandPartner struct {
	// ChannelHandle: Required. Channel handle, must begin with "@"
	ChannelHandle string `json:"channelHandle,omitempty"`
	// ChannelId: Required. External Channel ID, must begin with "UC"
	ChannelId string `json:"channelId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelHandle") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ChannelHandle") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s BrandPartner) MarshalJSON() ([]byte, error) {
	type NoMethod BrandPartner
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Caption: A *caption* resource represents a YouTube caption track. A caption
// track is associated with exactly one YouTube video.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Caption) MarshalJSON() ([]byte, error) {
	type NoMethod Caption
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CaptionListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod CaptionListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CaptionSnippet: Basic details about a caption track, such as its language
// and name.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CaptionSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod CaptionSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CdnSettings: Brief description of the live stream cdn settings.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CdnSettings) MarshalJSON() ([]byte, error) {
	type NoMethod CdnSettings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Channel: A *channel* resource contains information about a YouTube 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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Channel) MarshalJSON() ([]byte, error) {
	type NoMethod Channel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelAuditDetails: The auditDetails object encapsulates channel data that
// is relevant for YouTube Partners during the audit process.
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 or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelAuditDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelAuditDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelBannerResource: A channel banner returned as the response to a
// channel_banner.insert call.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelBannerResource) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelBannerResource
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelBrandingSettings: Branding properties of a YouTube channel.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelBrandingSettings) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelBrandingSettings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelContentDetails: Details about the content of a channel.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type ChannelContentDetailsRelatedPlaylists struct {
	// Favorites: The ID of the playlist that contains the channel"s favorite
	// videos. Use the `playlistItems.insert`
	// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
	// and `playlistItems.delete`
	// (https://developers.google.com/youtube/data/reference/rest/v3/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`
	// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
	// and `playlistItems.delete`
	// (https://developers.google.com/youtube/data/reference/rest/v3/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`
	// (https://developers.google.com/youtube/data/reference/rest/v3/videos/insert)
	// method to upload new videos and the `videos.delete`
	// (https://developers.google.com/youtube/data/reference/rest/v3/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`
	// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
	// and `playlistItems.delete`
	// (https://developers.google.com/youtube/data/reference/rest/v3/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`
	// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
	// and `playlistItems.delete`
	// (https://developers.google.com/youtube/data/reference/rest/v3/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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelContentDetailsRelatedPlaylists) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelContentDetailsRelatedPlaylists
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelContentOwnerDetails: The contentOwnerDetails object encapsulates
// channel data that is relevant for YouTube Partners linked with the channel.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelContentOwnerDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelContentOwnerDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// 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.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelConversionPing) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelConversionPing
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelConversionPings: The conversionPings object encapsulates information
// about conversion pings that need to be respected by the channel.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelConversionPings) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelConversionPings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelLocalization: Channel localization setting
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelLocalization) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelLocalization
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelProfileDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelProfileDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSection) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSection
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSectionContentDetails: Details about a channelsection, including
// playlists and channels.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSectionContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSectionContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSectionListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSectionListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSectionLocalization: ChannelSection localization setting
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSectionLocalization) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSectionLocalization
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSectionSnippet: Basic details about a channel section, including
// title, style and position.
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:
	//   "channelsectionTypeUndefined"
	//   "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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSectionSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSectionSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSectionTargeting: ChannelSection targeting setting.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSectionTargeting) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSectionTargeting
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSettings: Branding properties for the channel view.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSettings) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSettings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelSnippet: Basic details about a channel, including title, description
// and thumbnails.
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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelStatistics: Statistics about a channel: number of subscribers, number
// of videos in the channel, etc.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelStatistics) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelStatistics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelStatus: JSON template for the status part of a channel.
type ChannelStatus struct {
	// IsChannelMonetizationEnabled: Whether the channel is considered ypp
	// monetization enabled. See go/yppornot for more details.
	IsChannelMonetizationEnabled bool `json:"isChannelMonetizationEnabled,omitempty"`
	// 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.
	// "IsChannelMonetizationEnabled") to unconditionally include in API requests.
	// By default, fields with empty or default values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields
	// for more details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "IsChannelMonetizationEnabled") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelStatus) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelToAffiliateProgramLinkDetails: Information specific to a creator in
// an affiliate program linked to a YouTube channel.
type ChannelToAffiliateProgramLinkDetails struct {
	// MerchantId: Required. Google Merchant Center ID of the partner.
	MerchantId uint64 `json:"merchantId,omitempty,string"`
	// ProgramStatus: Required. Affiliate program status.
	//
	// Possible values:
	//   "affiliateProgramStatusUnspecified" - Unspecified status.
	//   "active" - Channel is active in the affiliate program.
	//   "inactive" - Channel is inactive in the affiliate program.
	ProgramStatus string `json:"programStatus,omitempty"`
	// StatusUpdateReason: Optional. Reason for the last update of the affiliate
	// program status.
	StatusUpdateReason string `json:"statusUpdateReason,omitempty"`
	// StatusUpdateTime: Optional. Timestamp when the affiliate program status was
	// last updated.
	StatusUpdateTime string `json:"statusUpdateTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MerchantId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MerchantId") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelToAffiliateProgramLinkDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelToAffiliateProgramLinkDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelToStoreLinkDetails: Information specific to a store on a
// merchandising platform linked to a YouTube channel.
type ChannelToStoreLinkDetails struct {
	// BillingDetails: Information specific to billing (read-only).
	BillingDetails *ChannelToStoreLinkDetailsBillingDetails `json:"billingDetails,omitempty"`
	// MerchantAffiliateProgramDetails: Information specific to merchant affiliate
	// program (read-only).
	MerchantAffiliateProgramDetails *ChannelToStoreLinkDetailsMerchantAffiliateProgramDetails `json:"merchantAffiliateProgramDetails,omitempty"`
	// MerchantId: Google Merchant Center id of the store.
	MerchantId uint64 `json:"merchantId,omitempty,string"`
	// 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. "BillingDetails") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BillingDetails") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelToStoreLinkDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelToStoreLinkDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelToStoreLinkDetailsBillingDetails: Information specific to billing.
type ChannelToStoreLinkDetailsBillingDetails struct {
	// BillingStatus: The current billing profile status.
	//
	// Possible values:
	//   "billingStatusUnspecified"
	//   "billingStatusPending"
	//   "billingStatusActive"
	//   "billingStatusInactive"
	BillingStatus string `json:"billingStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BillingStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BillingStatus") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelToStoreLinkDetailsBillingDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelToStoreLinkDetailsBillingDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelToStoreLinkDetailsMerchantAffiliateProgramDetails: Information
// specific to merchant affiliate program.
type ChannelToStoreLinkDetailsMerchantAffiliateProgramDetails struct {
	// Status: The current merchant affiliate program status.
	//
	// Possible values:
	//   "merchantAffiliateProgramStatusUnspecified" - Unspecified status.
	//   "merchantAffiliateProgramStatusEligible" - Merchant is eligible for the
	// merchant affiliate program.
	//   "merchantAffiliateProgramStatusActive" - Merchant affiliate program is
	// active.
	//   "merchantAffiliateProgramStatusPaused" - Merchant affiliate program is
	// paused.
	Status string `json:"status,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Status") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Status") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelToStoreLinkDetailsMerchantAffiliateProgramDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelToStoreLinkDetailsMerchantAffiliateProgramDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ChannelTopicDetails: Freebase topic information related to the channel.
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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ChannelTopicDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ChannelTopicDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Comment: A *comment* represents a single YouTube comment.
type Comment struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the comment.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#comment".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the comment.
	Snippet *CommentSnippet `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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Comment) MarshalJSON() ([]byte, error) {
	type NoMethod Comment
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type CommentListResponse 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 comments that match the request criteria.
	Items []*Comment `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#commentListResponse".
	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"`
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod CommentListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CommentSnippet: Basic details about a comment, such as its author and text.
type CommentSnippet struct {
	AuthorChannelId *CommentSnippetAuthorChannelId `json:"authorChannelId,omitempty"`
	// AuthorChannelUrl: Link to the author's YouTube channel, if any.
	AuthorChannelUrl string `json:"authorChannelUrl,omitempty"`
	// AuthorDisplayName: The name of the user who posted the comment.
	AuthorDisplayName string `json:"authorDisplayName,omitempty"`
	// AuthorProfileImageUrl: The URL for the avatar of the user who posted the
	// comment.
	AuthorProfileImageUrl string `json:"authorProfileImageUrl,omitempty"`
	// CanRate: Whether the current viewer can rate this comment.
	CanRate bool `json:"canRate,omitempty"`
	// ChannelId: The id of the corresponding YouTube channel. In case of a channel
	// comment this is the channel the comment refers to. In case of a video or
	// post comment it's the video/post's channel.
	ChannelId string `json:"channelId,omitempty"`
	// ImageUrl: Output only. The URL of the image or animated GIF attached to the
	// comment, if any. This property is only present when a comment contains an
	// image or GIF. The URL is served as a signed link with a six-hour time to
	// live (TTL) and expires six hours after retrieval.
	ImageUrl string `json:"imageUrl,omitempty"`
	// LikeCount: The total number of likes this comment has received.
	LikeCount int64 `json:"likeCount,omitempty"`
	// ModerationStatus: The comment's moderation status. Will not be set if the
	// comments were requested through the id filter.
	//
	// Possible values:
	//   "published" - The comment is available for public display.
	//   "heldForReview" - The comment is awaiting review by a moderator.
	//   "likelySpam"
	//   "rejected" - The comment is unfit for display.
	ModerationStatus string `json:"moderationStatus,omitempty"`
	// ParentId: The unique id of the top-level comment, only set for replies.
	ParentId string `json:"parentId,omitempty"`
	// PublishedAt: The date and time when the comment was originally published.
	PublishedAt string `json:"publishedAt,omitempty"`
	// TextDisplay: The comment's text. The format is either plain text or HTML
	// dependent on what has been requested. Even the plain text representation may
	// differ from the text originally posted in that it may replace video links
	// with video titles etc.
	TextDisplay string `json:"textDisplay,omitempty"`
	// TextOriginal: The comment's original raw text as initially posted or last
	// updated. The original text will only be returned if it is accessible to the
	// viewer, which is only guaranteed if the viewer is the comment's author.
	TextOriginal string `json:"textOriginal,omitempty"`
	// UpdatedAt: The date and time when the comment was last updated.
	UpdatedAt string `json:"updatedAt,omitempty"`
	// VideoId: The ID of the video the comment refers to, if any.
	VideoId string `json:"videoId,omitempty"`
	// ViewerRating: The rating the viewer has given to this comment. For the time
	// being this will never return RATE_TYPE_DISLIKE and instead return
	// RATE_TYPE_NONE. This may change in the future.
	//
	// Possible values:
	//   "none" - The entity has not been rated.
	//   "like" - The entity is liked.
	//   "dislike" - The entity is disliked.
	ViewerRating string `json:"viewerRating,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AuthorChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AuthorChannelId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod CommentSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CommentSnippetAuthorChannelId: Contains the id of the author's YouTube
// channel, if any.
type CommentSnippetAuthorChannelId struct {
	// Value: The id of the author's YouTube channel.
	Value string `json:"value,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Value") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Value") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentSnippetAuthorChannelId) MarshalJSON() ([]byte, error) {
	type NoMethod CommentSnippetAuthorChannelId
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CommentThread: A *comment thread* represents information that applies to a
// top level comment and all its replies. It can also include the top level
// comment itself and some of the replies.
type CommentThread struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the comment thread.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#commentThread".
	Kind string `json:"kind,omitempty"`
	// Replies: The replies object contains a limited number of replies (if any) to
	// the top level comment found in the snippet.
	Replies *CommentThreadReplies `json:"replies,omitempty"`
	// Snippet: The snippet object contains basic details about the comment thread
	// and also the top level comment.
	Snippet *CommentThreadSnippet `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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentThread) MarshalJSON() ([]byte, error) {
	type NoMethod CommentThread
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type CommentThreadListResponse 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 comment threads that match the request criteria.
	Items []*CommentThread `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#commentThreadListResponse".
	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"`
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentThreadListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod CommentThreadListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CommentThreadReplies: Comments written in (direct or indirect) reply to the
// top level comment.
type CommentThreadReplies struct {
	// Comments: A limited number of replies. Unless the number of replies returned
	// equals total_reply_count in the snippet the returned replies are only a
	// subset of the total number of replies.
	Comments []*Comment `json:"comments,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Comments") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Comments") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentThreadReplies) MarshalJSON() ([]byte, error) {
	type NoMethod CommentThreadReplies
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CommentThreadSnippet: Basic details about a comment thread.
type CommentThreadSnippet struct {
	// CanReply: Whether the current viewer of the thread can reply to it. This is
	// viewer specific - other viewers may see a different value for this field.
	CanReply bool `json:"canReply,omitempty"`
	// ChannelId: The YouTube channel the comments in the thread refer to or the
	// channel with the video the comments refer to. If neither video_id nor
	// post_id is set the comments refer to the channel itself.
	ChannelId string `json:"channelId,omitempty"`
	// IsPublic: Whether the thread (and therefore all its comments) is visible to
	// all YouTube users.
	IsPublic bool `json:"isPublic,omitempty"`
	// TopLevelComment: The top level comment of this thread.
	TopLevelComment *Comment `json:"topLevelComment,omitempty"`
	// TotalReplyCount: The total number of replies (not including the top level
	// comment).
	TotalReplyCount int64 `json:"totalReplyCount,omitempty"`
	// VideoId: The ID of the video the comments refer to, if any.
	VideoId string `json:"videoId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CanReply") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CanReply") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CommentThreadSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod CommentThreadSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ContentRating: Ratings schemes. The country-specific ratings are mostly for
// movies and shows. LINT.IfChange
type ContentRating struct {
	// AcbRating: The video's Australian Classification Board (ACB) or Australian
	// Communications and Media Authority (ACMA) rating. ACMA ratings are used to
	// classify children's television programming.
	//
	// Possible values:
	//   "acbUnspecified"
	//   "acbE" - E
	//   "acbP" - Programs that have been given a P classification by the
	// Australian Communications and Media Authority. These programs are intended
	// for preschool children.
	//   "acbC" - Programs that have been given a C classification by the
	// Australian Communications and Media Authority. These programs are intended
	// for children (other than preschool children) who are younger than 14 years
	// of age.
	//   "acbG" - G
	//   "acbPg" - PG
	//   "acbM" - M
	//   "acbMa15plus" - MA15+
	//   "acbR18plus" - R18+
	//   "acbUnrated"
	AcbRating string `json:"acbRating,omitempty"`
	// AgcomRating: The video's rating from Italy's Autorità per le Garanzie nelle
	// Comunicazioni (AGCOM).
	//
	// Possible values:
	//   "agcomUnspecified"
	//   "agcomT" - T
	//   "agcomVm14" - VM14
	//   "agcomVm18" - VM18
	//   "agcomUnrated"
	AgcomRating string `json:"agcomRating,omitempty"`
	// AnatelRating: The video's Anatel (Asociación Nacional de Televisión)
	// rating for Chilean television.
	//
	// Possible values:
	//   "anatelUnspecified"
	//   "anatelF" - F
	//   "anatelI" - I
	//   "anatelI7" - I-7
	//   "anatelI10" - I-10
	//   "anatelI12" - I-12
	//   "anatelR" - R
	//   "anatelA" - A
	//   "anatelUnrated"
	AnatelRating string `json:"anatelRating,omitempty"`
	// BbfcRating: The video's British Board of Film Classification (BBFC) rating.
	//
	// Possible values:
	//   "bbfcUnspecified"
	//   "bbfcU" - U
	//   "bbfcPg" - PG
	//   "bbfc12a" - 12A
	//   "bbfc12" - 12
	//   "bbfc15" - 15
	//   "bbfc18" - 18
	//   "bbfcR18" - R18
	//   "bbfcUnrated"
	BbfcRating string `json:"bbfcRating,omitempty"`
	// BfvcRating: The video's rating from Thailand's Board of Film and Video
	// Censors.
	//
	// Possible values:
	//   "bfvcUnspecified"
	//   "bfvcG" - G
	//   "bfvcE" - E
	//   "bfvc13" - 13
	//   "bfvc15" - 15
	//   "bfvc18" - 18
	//   "bfvc20" - 20
	//   "bfvcB" - B
	//   "bfvcUnrated"
	BfvcRating string `json:"bfvcRating,omitempty"`
	// BmukkRating: The video's rating from the Austrian Board of Media
	// Classification (Bundesministerium für Unterricht, Kunst und Kultur).
	//
	// Possible values:
	//   "bmukkUnspecified"
	//   "bmukkAa" - Unrestricted
	//   "bmukk6" - 6+
	//   "bmukk8" - 8+
	//   "bmukk10" - 10+
	//   "bmukk12" - 12+
	//   "bmukk14" - 14+
	//   "bmukk16" - 16+
	//   "bmukkUnrated"
	BmukkRating string `json:"bmukkRating,omitempty"`
	// CatvRating: Rating system for Canadian TV - Canadian TV Classification
	// System The video's rating from the Canadian Radio-Television and
	// Telecommunications Commission (CRTC) for Canadian English-language
	// broadcasts. For more information, see the Canadian Broadcast Standards
	// Council website.
	//
	// Possible values:
	//   "catvUnspecified"
	//   "catvC" - C
	//   "catvC8" - C8
	//   "catvG" - G
	//   "catvPg" - PG
	//   "catv14plus" - 14+
	//   "catv18plus" - 18+
	//   "catvUnrated"
	//   "catvE"
	CatvRating string `json:"catvRating,omitempty"`
	// CatvfrRating: The video's rating from the Canadian Radio-Television and
	// Telecommunications Commission (CRTC) for Canadian French-language
	// broadcasts. For more information, see the Canadian Broadcast Standards
	// Council website.
	//
	// Possible values:
	//   "catvfrUnspecified"
	//   "catvfrG" - G
	//   "catvfr8plus" - 8+
	//   "catvfr13plus" - 13+
	//   "catvfr16plus" - 16+
	//   "catvfr18plus" - 18+
	//   "catvfrUnrated"
	//   "catvfrE"
	CatvfrRating string `json:"catvfrRating,omitempty"`
	// CbfcRating: The video's Central Board of Film Certification (CBFC - India)
	// rating.
	//
	// Possible values:
	//   "cbfcUnspecified"
	//   "cbfcU" - U
	//   "cbfcUA" - U/A
	//   "cbfcUA7plus" - U/A 7+
	//   "cbfcUA13plus" - U/A 13+
	//   "cbfcUA16plus" - U/A 16+
	//   "cbfcA" - A
	//   "cbfcS" - S
	//   "cbfcUnrated"
	CbfcRating string `json:"cbfcRating,omitempty"`
	// CccRating: The video's Consejo de Calificación Cinematográfica (Chile)
	// rating.
	//
	// Possible values:
	//   "cccUnspecified"
	//   "cccTe" - Todo espectador
	//   "ccc6" - 6+ - Inconveniente para menores de 7 años
	//   "ccc14" - 14+
	//   "ccc18" - 18+
	//   "ccc18v" - 18+ - contenido excesivamente violento
	//   "ccc18s" - 18+ - contenido pornográfico
	//   "cccUnrated"
	CccRating string `json:"cccRating,omitempty"`
	// CceRating: The video's rating from Portugal's Comissão de Classificação
	// de Espect´culos.
	//
	// Possible values:
	//   "cceUnspecified"
	//   "cceM4" - 4
	//   "cceM6" - 6
	//   "cceM12" - 12
	//   "cceM16" - 16
	//   "cceM18" - 18
	//   "cceUnrated"
	//   "cceM14" - 14
	CceRating string `json:"cceRating,omitempty"`
	// ChfilmRating: The video's rating in Switzerland.
	//
	// Possible values:
	//   "chfilmUnspecified"
	//   "chfilm0" - 0
	//   "chfilm6" - 6
	//   "chfilm12" - 12
	//   "chfilm16" - 16
	//   "chfilm18" - 18
	//   "chfilmUnrated"
	ChfilmRating string `json:"chfilmRating,omitempty"`
	// ChvrsRating: The video's Canadian Home Video Rating System (CHVRS) rating.
	//
	// Possible values:
	//   "chvrsUnspecified"
	//   "chvrsG" - G
	//   "chvrsPg" - PG
	//   "chvrs14a" - 14A
	//   "chvrs18a" - 18A
	//   "chvrsR" - R
	//   "chvrsE" - E
	//   "chvrsUnrated"
	ChvrsRating string `json:"chvrsRating,omitempty"`
	// CicfRating: The video's rating from the Commission de Contrôle des Films
	// (Belgium).
	//
	// Possible values:
	//   "cicfUnspecified"
	//   "cicfE" - E
	//   "cicfKtEa" - KT/EA
	//   "cicfKntEna" - KNT/ENA
	//   "cicfUnrated"
	CicfRating string `json:"cicfRating,omitempty"`
	// CnaRating: The video's rating from Romania's CONSILIUL NATIONAL AL
	// AUDIOVIZUALULUI (CNA).
	//
	// Possible values:
	//   "cnaUnspecified"
	//   "cnaAp" - AP
	//   "cna12" - 12
	//   "cna15" - 15
	//   "cna18" - 18
	//   "cna18plus" - 18+
	//   "cnaUnrated"
	CnaRating string `json:"cnaRating,omitempty"`
	// CncRating: Rating system in France - Commission de classification
	// cinematographique
	//
	// Possible values:
	//   "cncUnspecified"
	//   "cncT" - T
	//   "cnc10" - 10
	//   "cnc12" - 12
	//   "cnc16" - 16
	//   "cnc18" - 18
	//   "cncE" - E
	//   "cncInterdiction" - interdiction
	//   "cncUnrated"
	CncRating string `json:"cncRating,omitempty"`
	// CsaRating: The video's rating from France's Conseil supérieur de
	// l’audiovisuel, which rates broadcast content.
	//
	// Possible values:
	//   "csaUnspecified"
	//   "csaT" - T
	//   "csa10" - 10
	//   "csa12" - 12
	//   "csa16" - 16
	//   "csa18" - 18
	//   "csaInterdiction" - Interdiction
	//   "csaUnrated"
	CsaRating string `json:"csaRating,omitempty"`
	// CscfRating: The video's rating from Luxembourg's Commission de surveillance
	// de la classification des films (CSCF).
	//
	// Possible values:
	//   "cscfUnspecified"
	//   "cscfAl" - AL
	//   "cscfA" - A
	//   "cscf6" - 6
	//   "cscf9" - 9
	//   "cscf12" - 12
	//   "cscf16" - 16
	//   "cscf18" - 18
	//   "cscfUnrated"
	CscfRating string `json:"cscfRating,omitempty"`
	// CzfilmRating: The video's rating in the Czech Republic.
	//
	// Possible values:
	//   "czfilmUnspecified"
	//   "czfilmU" - U
	//   "czfilm12" - 12
	//   "czfilm14" - 14
	//   "czfilm18" - 18
	//   "czfilmUnrated"
	CzfilmRating string `json:"czfilmRating,omitempty"`
	// DjctqRating: The video's Departamento de Justiça, Classificação,
	// Qualificação e Títulos (DJCQT - Brazil) rating.
	//
	// Possible values:
	//   "djctqUnspecified"
	//   "djctqL" - L
	//   "djctq10" - 10
	//   "djctq12" - 12
	//   "djctq14" - 14
	//   "djctq16" - 16
	//   "djctq18" - 18
	//   "djctqEr"
	//   "djctqL10"
	//   "djctqL12"
	//   "djctqL14"
	//   "djctqL16"
	//   "djctqL18"
	//   "djctq1012"
	//   "djctq1014"
	//   "djctq1016"
	//   "djctq1018"
	//   "djctq1214"
	//   "djctq1216"
	//   "djctq1218"
	//   "djctq1416"
	//   "djctq1418"
	//   "djctq1618"
	//   "djctqUnrated"
	DjctqRating string `json:"djctqRating,omitempty"`
	// DjctqRatingReasons: Reasons that explain why the video received its DJCQT
	// (Brazil) rating.
	//
	// Possible values:
	//   "djctqRatingReasonUnspecified"
	//   "djctqViolence" - Brazil rating content descriptors. See
	// http://go/brazilratings section F. Violência (Violence)
	//   "djctqExtremeViolence" - Violência extrema (Extreme violence)
	//   "djctqSexualContent" - Conteúdo sexual (Sexual content)
	//   "djctqNudity" - Nudez (Nudity)
	//   "djctqSex" - Sexo (Sex)
	//   "djctqExplicitSex" - Sexo Explícito (Explicit sex)
	//   "djctqDrugs" - Drogas (Drugs)
	//   "djctqLegalDrugs" - Drogas Lícitas (Legal drugs)
	//   "djctqIllegalDrugs" - Drogas Ilícitas (Illegal drugs)
	//   "djctqInappropriateLanguage" - Linguagem Imprópria (Inappropriate
	// language)
	//   "djctqCriminalActs" - Atos Criminosos (Criminal Acts)
	//   "djctqImpactingContent" - Conteúdo Impactante (Impacting content)
	//   "djctqFear" - Temer (Fear)
	//   "djctqMedicalProcedures" - Procedimentos médicos (Medical Procedures)
	//   "djctqSensitiveTopics" - Tópicos sensíveis (Sensitive Topics)
	//   "djctqFantasyViolence" - Fantasia Violência (Fantasy Violence)
	DjctqRatingReasons []string `json:"djctqRatingReasons,omitempty"`
	// EcbmctRating: Rating system in Turkey - Evaluation and Classification Board
	// of the Ministry of Culture and Tourism
	//
	// Possible values:
	//   "ecbmctUnspecified"
	//   "ecbmctG" - G
	//   "ecbmct7a" - 7A
	//   "ecbmct7plus" - 7+
	//   "ecbmct13a" - 13A
	//   "ecbmct13plus" - 13+
	//   "ecbmct15a" - 15A
	//   "ecbmct15plus" - 15+
	//   "ecbmct18plus" - 18+
	//   "ecbmctUnrated"
	EcbmctRating string `json:"ecbmctRating,omitempty"`
	// EefilmRating: The video's rating in Estonia.
	//
	// Possible values:
	//   "eefilmUnspecified"
	//   "eefilmPere" - Pere
	//   "eefilmL" - L
	//   "eefilmMs6" - MS-6
	//   "eefilmK6" - K-6
	//   "eefilmMs12" - MS-12
	//   "eefilmK12" - K-12
	//   "eefilmK14" - K-14
	//   "eefilmK16" - K-16
	//   "eefilmUnrated"
	EefilmRating string `json:"eefilmRating,omitempty"`
	// EgfilmRating: The video's rating in Egypt.
	//
	// Possible values:
	//   "egfilmUnspecified"
	//   "egfilmGn" - GN
	//   "egfilm18" - 18
	//   "egfilmBn" - BN
	//   "egfilmUnrated"
	EgfilmRating string `json:"egfilmRating,omitempty"`
	// EirinRating: The video's Eirin (映倫) rating. Eirin is the Japanese rating
	// system.
	//
	// Possible values:
	//   "eirinUnspecified"
	//   "eirinG" - G
	//   "eirinPg12" - PG-12
	//   "eirinR15plus" - R15+
	//   "eirinR18plus" - R18+
	//   "eirinUnrated"
	EirinRating string `json:"eirinRating,omitempty"`
	// FcbmRating: The video's rating from Malaysia's Film Censorship Board.
	//
	// Possible values:
	//   "fcbmUnspecified"
	//   "fcbmU" - U
	//   "fcbmPg13" - PG13
	//   "fcbmP13" - P13
	//   "fcbm18" - 18
	//   "fcbm18sx" - 18SX
	//   "fcbm18pa" - 18PA
	//   "fcbm18sg" - 18SG
	//   "fcbm18pl" - 18PL
	//   "fcbmUnrated"
	FcbmRating string `json:"fcbmRating,omitempty"`
	// FcoRating: The video's rating from Hong Kong's Office for Film, Newspaper
	// and Article Administration.
	//
	// Possible values:
	//   "fcoUnspecified"
	//   "fcoI" - I
	//   "fcoIia" - IIA
	//   "fcoIib" - IIB
	//   "fcoIi" - II
	//   "fcoIii" - III
	//   "fcoUnrated"
	FcoRating string `json:"fcoRating,omitempty"`
	// FmocRating: This property has been deprecated. Use the
	// contentDetails.contentRating.cncRating instead.
	//
	// Possible values:
	//   "fmocUnspecified"
	//   "fmocU" - U
	//   "fmoc10" - 10
	//   "fmoc12" - 12
	//   "fmoc16" - 16
	//   "fmoc18" - 18
	//   "fmocE" - E
	//   "fmocUnrated"
	FmocRating string `json:"fmocRating,omitempty"`
	// FpbRating: The video's rating from South Africa's Film and Publication
	// Board.
	//
	// Possible values:
	//   "fpbUnspecified"
	//   "fpbA" - A
	//   "fpbPg" - PG
	//   "fpb79Pg" - 7-9PG
	//   "fpb1012Pg" - 10-12PG
	//   "fpb13" - 13
	//   "fpb16" - 16
	//   "fpb18" - 18
	//   "fpbX18" - X18
	//   "fpbXx" - XX
	//   "fpbUnrated"
	//   "fpb10" - 10
	FpbRating string `json:"fpbRating,omitempty"`
	// FpbRatingReasons: Reasons that explain why the video received its FPB (South
	// Africa) rating.
	//
	// Possible values:
	//   "fpbRatingReasonUnspecified"
	//   "fpbBlasphemy" - South Africa rating content descriptors.
	//   "fpbLanguage"
	//   "fpbNudity"
	//   "fpbPrejudice"
	//   "fpbSex"
	//   "fpbViolence"
	//   "fpbDrugs"
	//   "fpbSexualViolence"
	//   "fpbHorror"
	//   "fpbCriminalTechniques"
	//   "fpbImitativeActsTechniques"
	FpbRatingReasons []string `json:"fpbRatingReasons,omitempty"`
	// FskRating: The video's Freiwillige Selbstkontrolle der Filmwirtschaft (FSK -
	// Germany) rating.
	//
	// Possible values:
	//   "fskUnspecified"
	//   "fsk0" - FSK 0
	//   "fsk6" - FSK 6
	//   "fsk12" - FSK 12
	//   "fsk16" - FSK 16
	//   "fsk18" - FSK 18
	//   "fskUnrated"
	FskRating string `json:"fskRating,omitempty"`
	// GrfilmRating: The video's rating in Greece.
	//
	// Possible values:
	//   "grfilmUnspecified"
	//   "grfilmK" - K
	//   "grfilmE" - E
	//   "grfilmK12" - K-12
	//   "grfilmK13" - K-13
	//   "grfilmK15" - K-15
	//   "grfilmK17" - K-17
	//   "grfilmK18" - K-18
	//   "grfilmUnrated"
	GrfilmRating string `json:"grfilmRating,omitempty"`
	// IcaaRating: The video's Instituto de la Cinematografía y de las Artes
	// Audiovisuales (ICAA - Spain) rating.
	//
	// Possible values:
	//   "icaaUnspecified"
	//   "icaaApta" - APTA
	//   "icaa7" - 7
	//   "icaa12" - 12
	//   "icaa13" - 13
	//   "icaa16" - 16
	//   "icaa18" - 18
	//   "icaaX" - X
	//   "icaaUnrated"
	IcaaRating string `json:"icaaRating,omitempty"`
	// IfcoRating: The video's Irish Film Classification Office (IFCO - Ireland)
	// rating. See the IFCO website for more information.
	//
	// Possible values:
	//   "ifcoUnspecified"
	//   "ifcoG" - G
	//   "ifcoPg" - PG
	//   "ifco12" - 12
	//   "ifco12a" - 12A
	//   "ifco15" - 15
	//   "ifco15a" - 15A
	//   "ifco16" - 16
	//   "ifco18" - 18
	//   "ifcoUnrated"
	IfcoRating string `json:"ifcoRating,omitempty"`
	// IlfilmRating: The video's rating in Israel.
	//
	// Possible values:
	//   "ilfilmUnspecified"
	//   "ilfilmAa" - AA
	//   "ilfilm12" - 12
	//   "ilfilm14" - 14
	//   "ilfilm16" - 16
	//   "ilfilm18" - 18
	//   "ilfilmUnrated"
	IlfilmRating string `json:"ilfilmRating,omitempty"`
	// IncaaRating: The video's INCAA (Instituto Nacional de Cine y Artes
	// Audiovisuales - Argentina) rating.
	//
	// Possible values:
	//   "incaaUnspecified"
	//   "incaaAtp" - ATP (Apta para todo publico)
	//   "incaaSam13" - 13 (Solo apta para mayores de 13 años)
	//   "incaaSam16" - 16 (Solo apta para mayores de 16 años)
	//   "incaaSam18" - 18 (Solo apta para mayores de 18 años)
	//   "incaaC" - X (Solo apta para mayores de 18 años, de exhibición
	// condicionada)
	//   "incaaUnrated"
	IncaaRating string `json:"incaaRating,omitempty"`
	// KfcbRating: The video's rating from the Kenya Film Classification Board.
	//
	// Possible values:
	//   "kfcbUnspecified"
	//   "kfcbG" - GE
	//   "kfcbPg" - PG
	//   "kfcb16plus" - 16
	//   "kfcbR" - 18
	//   "kfcbUnrated"
	KfcbRating string `json:"kfcbRating,omitempty"`
	// KijkwijzerRating: The video's NICAM/Kijkwijzer rating from the Nederlands
	// Instituut voor de Classificatie van Audiovisuele Media (Netherlands).
	//
	// Possible values:
	//   "kijkwijzerUnspecified"
	//   "kijkwijzerAl" - AL
	//   "kijkwijzer6" - 6
	//   "kijkwijzer9" - 9
	//   "kijkwijzer12" - 12
	//   "kijkwijzer16" - 16
	//   "kijkwijzer18"
	//   "kijkwijzerUnrated"
	KijkwijzerRating string `json:"kijkwijzerRating,omitempty"`
	// KmrbRating: The video's Korea Media Rating Board (영상물등급위원회)
	// rating. The KMRB rates videos in South Korea.
	//
	// Possible values:
	//   "kmrbUnspecified"
	//   "kmrbAll" - 전체관람가
	//   "kmrb12plus" - 12세 이상 관람가
	//   "kmrb15plus" - 15세 이상 관람가
	//   "kmrbTeenr"
	//   "kmrbR" - 청소년 관람불가
	//   "kmrbUnrated"
	KmrbRating string `json:"kmrbRating,omitempty"`
	// LsfRating: The video's rating from Indonesia's Lembaga Sensor Film.
	//
	// Possible values:
	//   "lsfUnspecified"
	//   "lsfSu" - SU
	//   "lsfA" - A
	//   "lsfBo" - BO
	//   "lsf13" - 13
	//   "lsfR" - R
	//   "lsf17" - 17
	//   "lsfD" - D
	//   "lsf21" - 21
	//   "lsfUnrated"
	LsfRating string `json:"lsfRating,omitempty"`
	// MccaaRating: The video's rating from Malta's Film Age-Classification Board.
	//
	// Possible values:
	//   "mccaaUnspecified"
	//   "mccaaU" - U
	//   "mccaaPg" - PG
	//   "mccaa12a" - 12A
	//   "mccaa12" - 12
	//   "mccaa14" - 14 - this rating was removed from the new classification
	// structure introduced in 2013.
	//   "mccaa15" - 15
	//   "mccaa16" - 16 - this rating was removed from the new classification
	// structure introduced in 2013.
	//   "mccaa18" - 18
	//   "mccaaUnrated"
	MccaaRating string `json:"mccaaRating,omitempty"`
	// MccypRating: The video's rating from the Danish Film Institute's (Det Danske
	// Filminstitut) Media Council for Children and Young People.
	//
	// Possible values:
	//   "mccypUnspecified"
	//   "mccypA" - A
	//   "mccyp7" - 7
	//   "mccyp11" - 11
	//   "mccyp15" - 15
	//   "mccypUnrated"
	MccypRating string `json:"mccypRating,omitempty"`
	// McstRating: The video's rating system for Vietnam - MCST
	//
	// Possible values:
	//   "mcstUnspecified"
	//   "mcstP" - P
	//   "mcst0" - 0
	//   "mcstC13" - C13
	//   "mcstC16" - C16
	//   "mcst16plus" - 16+
	//   "mcstC18" - C18
	//   "mcstGPg" - MCST_G_PG
	//   "mcstUnrated"
	McstRating string `json:"mcstRating,omitempty"`
	// MdaRating: The video's rating from Singapore's Media Development Authority
	// (MDA) and, specifically, it's Board of Film Censors (BFC).
	//
	// Possible values:
	//   "mdaUnspecified"
	//   "mdaG" - G
	//   "mdaPg" - PG
	//   "mdaPg13" - PG13
	//   "mdaNc16" - NC16
	//   "mdaM18" - M18
	//   "mdaR21" - R21
	//   "mdaUnrated"
	MdaRating string `json:"mdaRating,omitempty"`
	// MedietilsynetRating: The video's rating from Medietilsynet, the Norwegian
	// Media Authority.
	//
	// Possible values:
	//   "medietilsynetUnspecified"
	//   "medietilsynetA" - A
	//   "medietilsynet6" - 6
	//   "medietilsynet7" - 7
	//   "medietilsynet9" - 9
	//   "medietilsynet11" - 11
	//   "medietilsynet12" - 12
	//   "medietilsynet15" - 15
	//   "medietilsynet18" - 18
	//   "medietilsynetUnrated"
	MedietilsynetRating string `json:"medietilsynetRating,omitempty"`
	// MekuRating: The video's rating from Finland's Kansallinen Audiovisuaalinen
	// Instituutti (National Audiovisual Institute).
	//
	// Possible values:
	//   "mekuUnspecified"
	//   "mekuS" - S
	//   "meku7" - 7
	//   "meku12" - 12
	//   "meku16" - 16
	//   "meku18" - 18
	//   "mekuUnrated"
	MekuRating string `json:"mekuRating,omitempty"`
	// MenaMpaaRating: The rating system for MENA countries, a clone of MPAA. It is
	// needed to prevent titles go live w/o additional QC check, since some of them
	// can be inappropriate for the countries at all. See b/33408548 for more
	// details.
	//
	// Possible values:
	//   "menaMpaaUnspecified"
	//   "menaMpaaG" - G
	//   "menaMpaaPg" - PG
	//   "menaMpaaPg13" - PG-13
	//   "menaMpaaR" - R
	//   "menaMpaaUnrated" - To keep the same enum values as MPAA's items have,
	// skip NC_17.
	MenaMpaaRating string `json:"menaMpaaRating,omitempty"`
	// MibacRating: The video's rating from the Ministero dei Beni e delle
	// Attività Culturali e del Turismo (Italy).
	//
	// Possible values:
	//   "mibacUnspecified"
	//   "mibacT"
	//   "mibacVap"
	//   "mibacVm6"
	//   "mibacVm12"
	//   "mibacVm14"
	//   "mibacVm16"
	//   "mibacVm18"
	//   "mibacUnrated"
	MibacRating string `json:"mibacRating,omitempty"`
	// MocRating: The video's Ministerio de Cultura (Colombia) rating.
	//
	// Possible values:
	//   "mocUnspecified"
	//   "mocE" - E
	//   "mocT" - T
	//   "moc7" - 7
	//   "moc12" - 12
	//   "moc15" - 15
	//   "moc18" - 18
	//   "mocX" - X
	//   "mocBanned" - Banned
	//   "mocUnrated"
	MocRating string `json:"mocRating,omitempty"`
	// MoctwRating: The video's rating from Taiwan's Ministry of Culture
	// (文化部).
	//
	// Possible values:
	//   "moctwUnspecified"
	//   "moctwG" - G
	//   "moctwP" - P
	//   "moctwPg" - PG
	//   "moctwR" - R
	//   "moctwUnrated"
	//   "moctwR12" - R-12
	//   "moctwR15" - R-15
	MoctwRating string `json:"moctwRating,omitempty"`
	// MpaaRating: The video's Motion Picture Association of America (MPAA) rating.
	//
	// Possible values:
	//   "mpaaUnspecified"
	//   "mpaaG" - G
	//   "mpaaPg" - PG
	//   "mpaaPg13" - PG-13
	//   "mpaaR" - R
	//   "mpaaNc17" - NC-17
	//   "mpaaX" - ! X
	//   "mpaaUnrated"
	MpaaRating string `json:"mpaaRating,omitempty"`
	// MpaatRating: The rating system for trailer, DVD, and Ad in the US. See
	// http://movielabs.com/md/ratings/v2.3/html/US_MPAAT_Ratings.html.
	//
	// Possible values:
	//   "mpaatUnspecified"
	//   "mpaatGb" - GB
	//   "mpaatRb" - RB
	MpaatRating string `json:"mpaatRating,omitempty"`
	// MtrcbRating: The video's rating from the Movie and Television Review and
	// Classification Board (Philippines).
	//
	// Possible values:
	//   "mtrcbUnspecified"
	//   "mtrcbG" - G
	//   "mtrcbPg" - PG
	//   "mtrcbR13" - R-13
	//   "mtrcbR16" - R-16
	//   "mtrcbR18" - R-18
	//   "mtrcbX" - X
	//   "mtrcbUnrated"
	MtrcbRating string `json:"mtrcbRating,omitempty"`
	// NbcRating: The video's rating from the Maldives National Bureau of
	// Classification.
	//
	// Possible values:
	//   "nbcUnspecified"
	//   "nbcG" - G
	//   "nbcPg" - PG
	//   "nbc12plus" - 12+
	//   "nbc15plus" - 15+
	//   "nbc18plus" - 18+
	//   "nbc18plusr" - 18+R
	//   "nbcPu" - PU
	//   "nbcUnrated"
	NbcRating string `json:"nbcRating,omitempty"`
	// NbcplRating: The video's rating in Poland.
	//
	// Possible values:
	//   "nbcplUnspecified"
	//   "nbcplI"
	//   "nbcplIi"
	//   "nbcplIii"
	//   "nbcplIv"
	//   "nbcpl18plus"
	//   "nbcplUnrated"
	NbcplRating string `json:"nbcplRating,omitempty"`
	// NfrcRating: The video's rating from the Bulgarian National Film Center.
	//
	// Possible values:
	//   "nfrcUnspecified"
	//   "nfrcA" - A
	//   "nfrcB" - B
	//   "nfrcC" - C
	//   "nfrcD" - D
	//   "nfrcX" - X
	//   "nfrcUnrated"
	NfrcRating string `json:"nfrcRating,omitempty"`
	// NfvcbRating: The video's rating from Nigeria's National Film and Video
	// Censors Board.
	//
	// Possible values:
	//   "nfvcbUnspecified"
	//   "nfvcbG" - G
	//   "nfvcbPg" - PG
	//   "nfvcb12" - 12
	//   "nfvcb12a" - 12A
	//   "nfvcb15" - 15
	//   "nfvcb18" - 18
	//   "nfvcbRe" - RE
	//   "nfvcbUnrated"
	NfvcbRating string `json:"nfvcbRating,omitempty"`
	// NkclvRating: The video's rating from the Nacionãlais Kino centrs (National
	// Film Centre of Latvia).
	//
	// Possible values:
	//   "nkclvUnspecified"
	//   "nkclvU" - U
	//   "nkclv7plus" - 7+
	//   "nkclv12plus" - 12+
	//   "nkclv16plus" - ! 16+
	//   "nkclv18plus" - 18+
	//   "nkclvUnrated"
	NkclvRating string `json:"nkclvRating,omitempty"`
	// NmcRating: The National Media Council ratings system for United Arab
	// Emirates.
	//
	// Possible values:
	//   "nmcUnspecified"
	//   "nmcG" - G
	//   "nmcPg" - PG
	//   "nmcPg13" - PG-13
	//   "nmcPg15" - PG-15
	//   "nmc15plus" - 15+
	//   "nmc18plus" - 18+
	//   "nmc18tc" - 18TC
	//   "nmcUnrated"
	NmcRating string `json:"nmcRating,omitempty"`
	// OflcRating: The video's Office of Film and Literature Classification (OFLC -
	// New Zealand) rating.
	//
	// Possible values:
	//   "oflcUnspecified"
	//   "oflcG" - G
	//   "oflcPg" - PG
	//   "oflcM" - M
	//   "oflcR13" - R13
	//   "oflcR15" - R15
	//   "oflcR16" - R16
	//   "oflcR18" - R18
	//   "oflcUnrated"
	//   "oflcRp13" - RP13
	//   "oflcRp16" - RP16
	//   "oflcRp18" - RP18
	OflcRating string `json:"oflcRating,omitempty"`
	// PefilmRating: The video's rating in Peru.
	//
	// Possible values:
	//   "pefilmUnspecified"
	//   "pefilmPt" - PT
	//   "pefilmPg" - PG
	//   "pefilm14" - 14
	//   "pefilm18" - 18
	//   "pefilmUnrated"
	PefilmRating string `json:"pefilmRating,omitempty"`
	// RcnofRating: The video's rating from the Hungarian Nemzeti Filmiroda, the
	// Rating Committee of the National Office of Film.
	//
	// Possible values:
	//   "rcnofUnspecified"
	//   "rcnofI"
	//   "rcnofIi"
	//   "rcnofIii"
	//   "rcnofIv"
	//   "rcnofV"
	//   "rcnofVi"
	//   "rcnofUnrated"
	RcnofRating string `json:"rcnofRating,omitempty"`
	// ResorteviolenciaRating: The video's rating in Venezuela.
	//
	// Possible values:
	//   "resorteviolenciaUnspecified"
	//   "resorteviolenciaA" - A
	//   "resorteviolenciaB" - B
	//   "resorteviolenciaC" - C
	//   "resorteviolenciaD" - D
	//   "resorteviolenciaE" - E
	//   "resorteviolenciaUnrated"
	ResorteviolenciaRating string `json:"resorteviolenciaRating,omitempty"`
	// RtcRating: The video's General Directorate of Radio, Television and
	// Cinematography (Mexico) rating.
	//
	// Possible values:
	//   "rtcUnspecified"
	//   "rtcAa" - AA
	//   "rtcA" - A
	//   "rtcB" - B
	//   "rtcB15" - B15
	//   "rtcC" - C
	//   "rtcD" - D
	//   "rtcUnrated"
	RtcRating string `json:"rtcRating,omitempty"`
	// RteRating: The video's rating from Ireland's Raidió Teilifís Éireann.
	//
	// Possible values:
	//   "rteUnspecified"
	//   "rteGa" - GA
	//   "rteCh" - CH
	//   "rtePs" - PS
	//   "rteMa" - MA
	//   "rteUnrated"
	RteRating string `json:"rteRating,omitempty"`
	// RussiaRating: The video's National Film Registry of the Russian Federation
	// (MKRF - Russia) rating.
	//
	// Possible values:
	//   "russiaUnspecified"
	//   "russia0" - 0+
	//   "russia6" - 6+
	//   "russia12" - 12+
	//   "russia16" - 16+
	//   "russia18" - 18+
	//   "russiaUnrated"
	RussiaRating string `json:"russiaRating,omitempty"`
	// SkfilmRating: The video's rating in Slovakia.
	//
	// Possible values:
	//   "skfilmUnspecified"
	//   "skfilmG" - G
	//   "skfilmP2" - P2
	//   "skfilmP5" - P5
	//   "skfilmP8" - P8
	//   "skfilmUnrated"
	SkfilmRating string `json:"skfilmRating,omitempty"`
	// SmaisRating: The video's rating in Iceland.
	//
	// Possible values:
	//   "smaisUnspecified"
	//   "smaisL" - L
	//   "smais7" - 7
	//   "smais12" - 12
	//   "smais14" - 14
	//   "smais16" - 16
	//   "smais18" - 18
	//   "smaisUnrated"
	SmaisRating string `json:"smaisRating,omitempty"`
	// SmsaRating: The video's rating from Statens medieråd (Sweden's National
	// Media Council).
	//
	// Possible values:
	//   "smsaUnspecified"
	//   "smsaA" - All ages
	//   "smsa7" - 7
	//   "smsa11" - 11
	//   "smsa15" - 15
	//   "smsaUnrated"
	SmsaRating string `json:"smsaRating,omitempty"`
	// TvpgRating: The video's TV Parental Guidelines (TVPG) rating.
	//
	// Possible values:
	//   "tvpgUnspecified"
	//   "tvpgY" - TV-Y
	//   "tvpgY7" - TV-Y7
	//   "tvpgY7Fv" - TV-Y7-FV
	//   "tvpgG" - TV-G
	//   "tvpgPg" - TV-PG
	//   "pg14" - TV-14
	//   "tvpgMa" - TV-MA
	//   "tvpgUnrated"
	TvpgRating string `json:"tvpgRating,omitempty"`
	// YtRating: A rating that YouTube uses to identify age-restricted content.
	//
	// Possible values:
	//   "ytUnspecified"
	//   "ytAgeRestricted"
	YtRating string `json:"ytRating,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AcbRating") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AcbRating") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ContentRating) MarshalJSON() ([]byte, error) {
	type NoMethod ContentRating
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Cuepoint: Note that there may be a 5-second end-point resolution issue. For
// instance, if a cuepoint comes in for 22:03:27, we may stuff the cuepoint
// into 22:03:25 or 22:03:30, depending. This is an artifact of HLS.
type Cuepoint struct {
	// Possible values:
	//   "cueTypeUnspecified"
	//   "cueTypeAd"
	CueType string `json:"cueType,omitempty"`
	// DurationSecs: The duration of this cuepoint.
	DurationSecs int64  `json:"durationSecs,omitempty"`
	Etag         string `json:"etag,omitempty"`
	// Id: The identifier for cuepoint resource.
	Id string `json:"id,omitempty"`
	// InsertionOffsetTimeMs: The time when the cuepoint should be inserted by
	// offset to the broadcast actual start time.
	InsertionOffsetTimeMs int64 `json:"insertionOffsetTimeMs,omitempty,string"`
	// WalltimeMs: The wall clock time at which the cuepoint should be inserted.
	// Only one of insertion_offset_time_ms and walltime_ms may be set at a time.
	WalltimeMs uint64 `json:"walltimeMs,omitempty,string"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "CueType") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CueType") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Cuepoint) MarshalJSON() ([]byte, error) {
	type NoMethod Cuepoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// CuepointSchedule: Schedule to insert cuepoints into a broadcast by ads
// automator.
type CuepointSchedule struct {
	// Enabled: This field is semantically required. If it is set false or not set,
	// other fields in this message will be ignored.
	Enabled bool `json:"enabled,omitempty"`
	// PauseAdsUntil: If set, automatic cuepoint insertion is paused until this
	// timestamp ("No Ad Zone"). The value is specified in ISO 8601 format.
	PauseAdsUntil string `json:"pauseAdsUntil,omitempty"`
	// RepeatIntervalSecs: Interval frequency in seconds that api uses to insert
	// cuepoints automatically.
	RepeatIntervalSecs int64 `json:"repeatIntervalSecs,omitempty"`
	// ScheduleStrategy: The strategy to use when scheduling cuepoints.
	//
	// Possible values:
	//   "scheduleStrategyUnspecified"
	//   "concurrent" - Strategy to schedule cuepoints at one time for all viewers.
	//   "nonConcurrent" - Strategy to schedule cuepoints at an increased rate to
	// allow viewers to receive cuepoints when eligible. See
	// go/lcr-non-concurrent-ads for more details.
	ScheduleStrategy string `json:"scheduleStrategy,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Enabled") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Enabled") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s CuepointSchedule) MarshalJSON() ([]byte, error) {
	type NoMethod CuepointSchedule
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type Entity struct {
	Id     string `json:"id,omitempty"`
	TypeId string `json:"typeId,omitempty"`
	Url    string `json:"url,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Id") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Entity) MarshalJSON() ([]byte, error) {
	type NoMethod Entity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// GeoPoint: Geographical coordinates of a point, in WGS84.
type GeoPoint struct {
	// Altitude: Altitude above the reference ellipsoid, in meters.
	Altitude float64 `json:"altitude,omitempty"`
	// Latitude: Latitude in degrees.
	Latitude float64 `json:"latitude,omitempty"`
	// Longitude: Longitude in degrees.
	Longitude float64 `json:"longitude,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Altitude") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Altitude") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s GeoPoint) MarshalJSON() ([]byte, error) {
	type NoMethod GeoPoint
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *GeoPoint) UnmarshalJSON(data []byte) error {
	type NoMethod GeoPoint
	var s1 struct {
		Altitude  gensupport.JSONFloat64 `json:"altitude"`
		Latitude  gensupport.JSONFloat64 `json:"latitude"`
		Longitude gensupport.JSONFloat64 `json:"longitude"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.Altitude = float64(s1.Altitude)
	s.Latitude = float64(s1.Latitude)
	s.Longitude = float64(s1.Longitude)
	return nil
}

// I18nLanguage: An *i18nLanguage* resource identifies a UI language currently
// supported by YouTube.
type I18nLanguage struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the i18n language.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#i18nLanguage".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the i18n language,
	// such as language code and human-readable name.
	Snippet *I18nLanguageSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nLanguage) MarshalJSON() ([]byte, error) {
	type NoMethod I18nLanguage
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type I18nLanguageListResponse 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 supported i18n languages. In this map, the i18n language ID
	// is the map key, and its value is the corresponding i18nLanguage resource.
	Items []*I18nLanguage `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#i18nLanguageListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nLanguageListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod I18nLanguageListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// I18nLanguageSnippet: Basic details about an i18n language, such as language
// code and human-readable name.
type I18nLanguageSnippet struct {
	// Hl: A short BCP-47 code that uniquely identifies a language.
	Hl string `json:"hl,omitempty"`
	// Name: The human-readable name of the language in the language itself.
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Hl") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Hl") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nLanguageSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod I18nLanguageSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// I18nRegion: A *i18nRegion* resource identifies a region where YouTube is
// available.
type I18nRegion struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the i18n region.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#i18nRegion".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the i18n region,
	// such as region code and human-readable name.
	Snippet *I18nRegionSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nRegion) MarshalJSON() ([]byte, error) {
	type NoMethod I18nRegion
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type I18nRegionListResponse 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 regions where YouTube is available. In this map, the i18n
	// region ID is the map key, and its value is the corresponding i18nRegion
	// resource.
	Items []*I18nRegion `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#i18nRegionListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nRegionListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod I18nRegionListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// I18nRegionSnippet: Basic details about an i18n region, such as region code
// and human-readable name.
type I18nRegionSnippet struct {
	// Gl: The region code as a 2-letter ISO country code.
	Gl string `json:"gl,omitempty"`
	// Name: The human-readable name of the region.
	Name string `json:"name,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Gl") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Gl") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s I18nRegionSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod I18nRegionSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ImageSettings: Branding properties for images associated with the channel.
type ImageSettings struct {
	// BackgroundImageUrl: The URL for the background image shown on the video
	// watch page. The image should be 1200px by 615px, with a maximum file size of
	// 128k.
	BackgroundImageUrl *LocalizedProperty `json:"backgroundImageUrl,omitempty"`
	// BannerExternalUrl: This is generated when a ChannelBanner.Insert request has
	// succeeded for the given channel.
	BannerExternalUrl string `json:"bannerExternalUrl,omitempty"`
	// BannerImageUrl: Banner image. Desktop size (1060x175).
	BannerImageUrl string `json:"bannerImageUrl,omitempty"`
	// BannerMobileExtraHdImageUrl: Banner image. Mobile size high resolution
	// (1440x395).
	BannerMobileExtraHdImageUrl string `json:"bannerMobileExtraHdImageUrl,omitempty"`
	// BannerMobileHdImageUrl: Banner image. Mobile size high resolution
	// (1280x360).
	BannerMobileHdImageUrl string `json:"bannerMobileHdImageUrl,omitempty"`
	// BannerMobileImageUrl: Banner image. Mobile size (640x175).
	BannerMobileImageUrl string `json:"bannerMobileImageUrl,omitempty"`
	// BannerMobileLowImageUrl: Banner image. Mobile size low resolution (320x88).
	BannerMobileLowImageUrl string `json:"bannerMobileLowImageUrl,omitempty"`
	// BannerMobileMediumHdImageUrl: Banner image. Mobile size medium/high
	// resolution (960x263).
	BannerMobileMediumHdImageUrl string `json:"bannerMobileMediumHdImageUrl,omitempty"`
	// BannerTabletExtraHdImageUrl: Banner image. Tablet size extra high resolution
	// (2560x424).
	BannerTabletExtraHdImageUrl string `json:"bannerTabletExtraHdImageUrl,omitempty"`
	// BannerTabletHdImageUrl: Banner image. Tablet size high resolution
	// (2276x377).
	BannerTabletHdImageUrl string `json:"bannerTabletHdImageUrl,omitempty"`
	// BannerTabletImageUrl: Banner image. Tablet size (1707x283).
	BannerTabletImageUrl string `json:"bannerTabletImageUrl,omitempty"`
	// BannerTabletLowImageUrl: Banner image. Tablet size low resolution
	// (1138x188).
	BannerTabletLowImageUrl string `json:"bannerTabletLowImageUrl,omitempty"`
	// BannerTvHighImageUrl: Banner image. TV size high resolution (1920x1080).
	BannerTvHighImageUrl string `json:"bannerTvHighImageUrl,omitempty"`
	// BannerTvImageUrl: Banner image. TV size extra high resolution (2120x1192).
	BannerTvImageUrl string `json:"bannerTvImageUrl,omitempty"`
	// BannerTvLowImageUrl: Banner image. TV size low resolution (854x480).
	BannerTvLowImageUrl string `json:"bannerTvLowImageUrl,omitempty"`
	// BannerTvMediumImageUrl: Banner image. TV size medium resolution (1280x720).
	BannerTvMediumImageUrl string `json:"bannerTvMediumImageUrl,omitempty"`
	// LargeBrandedBannerImageImapScript: The image map script for the large banner
	// image.
	LargeBrandedBannerImageImapScript *LocalizedProperty `json:"largeBrandedBannerImageImapScript,omitempty"`
	// LargeBrandedBannerImageUrl: The URL for the 854px by 70px image that appears
	// below the video player in the expanded video view of the video watch page.
	LargeBrandedBannerImageUrl *LocalizedProperty `json:"largeBrandedBannerImageUrl,omitempty"`
	// SmallBrandedBannerImageImapScript: The image map script for the small banner
	// image.
	SmallBrandedBannerImageImapScript *LocalizedProperty `json:"smallBrandedBannerImageImapScript,omitempty"`
	// SmallBrandedBannerImageUrl: The URL for the 640px by 70px banner image that
	// appears below the video player in the default view of the video watch page.
	// The URL for the image that appears above the top-left corner of the video
	// player. This is a 25-pixel-high image with a flexible width that cannot
	// exceed 170 pixels.
	SmallBrandedBannerImageUrl *LocalizedProperty `json:"smallBrandedBannerImageUrl,omitempty"`
	// TrackingImageUrl: The URL for a 1px by 1px tracking pixel that can be used
	// to collect statistics for views of the channel or video pages.
	TrackingImageUrl  string `json:"trackingImageUrl,omitempty"`
	WatchIconImageUrl string `json:"watchIconImageUrl,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BackgroundImageUrl") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BackgroundImageUrl") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ImageSettings) MarshalJSON() ([]byte, error) {
	type NoMethod ImageSettings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// IngestionInfo: Describes information necessary for ingesting an RTMP, HTTP,
// or SRT stream.
type IngestionInfo struct {
	// BackupIngestionAddress: The backup ingestion URL that you should use to
	// stream video to YouTube. You have the option of simultaneously streaming the
	// content that you are sending to the ingestionAddress to this URL.
	BackupIngestionAddress string `json:"backupIngestionAddress,omitempty"`
	// IngestionAddress: The primary ingestion URL that you should use to stream
	// video to YouTube. You must stream video to this URL. Depending on which
	// application or tool you use to encode your video stream, you may need to
	// enter the stream URL and stream name separately or you may need to
	// concatenate them in the following format: *STREAM_URL/STREAM_NAME*
	IngestionAddress string `json:"ingestionAddress,omitempty"`
	// RtmpsBackupIngestionAddress: This ingestion url may be used instead of
	// backupIngestionAddress in order to stream via RTMPS. Not applicable to
	// non-RTMP streams.
	RtmpsBackupIngestionAddress string `json:"rtmpsBackupIngestionAddress,omitempty"`
	// RtmpsIngestionAddress: This ingestion url may be used instead of
	// ingestionAddress in order to stream via RTMPS. Not applicable to non-RTMP
	// streams.
	RtmpsIngestionAddress string `json:"rtmpsIngestionAddress,omitempty"`
	// StreamName: The stream name that YouTube assigns to the video stream.
	StreamName string `json:"streamName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BackupIngestionAddress") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BackupIngestionAddress") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s IngestionInfo) MarshalJSON() ([]byte, error) {
	type NoMethod IngestionInfo
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Interval: Represents a time interval, encoded as a Timestamp start
// (inclusive) and a Timestamp end (exclusive). The start must be less than or
// equal to the end. When the start equals the end, the interval is empty
// (matches no time). When both start and end are unspecified, the interval
// matches any time.
type Interval struct {
	// EndTime: Optional. Exclusive end of the interval. If specified, a Timestamp
	// matching this interval will have to be before the end.
	EndTime string `json:"endTime,omitempty"`
	// StartTime: Optional. Inclusive start of the interval. If specified, a
	// Timestamp matching this interval will have to be the same or after the
	// start.
	StartTime string `json:"startTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EndTime") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Interval) MarshalJSON() ([]byte, error) {
	type NoMethod Interval
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// InvideoBranding: Describes an invideo branding.
type InvideoBranding struct {
	// ImageBytes: The bytes the uploaded image. Only used in api to youtube
	// communication.
	ImageBytes string `json:"imageBytes,omitempty"`
	// ImageUrl: The url of the uploaded image. Only used in apiary to api
	// communication.
	ImageUrl string `json:"imageUrl,omitempty"`
	// Position: The spatial position within the video where the branding watermark
	// will be displayed.
	Position *InvideoPosition `json:"position,omitempty"`
	// TargetChannelId: The channel to which this branding links. If not present it
	// defaults to the current channel.
	TargetChannelId string `json:"targetChannelId,omitempty"`
	// Timing: The temporal position within the video where watermark will be
	// displayed.
	Timing *InvideoTiming `json:"timing,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ImageBytes") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ImageBytes") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s InvideoBranding) MarshalJSON() ([]byte, error) {
	type NoMethod InvideoBranding
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// InvideoPosition: Describes the spatial position of a visual widget inside a
// video. It is a union of various position types, out of which only will be
// set one.
type InvideoPosition struct {
	// CornerPosition: Describes in which corner of the video the visual widget
	// will appear.
	//
	// Possible values:
	//   "topLeft"
	//   "topRight"
	//   "bottomLeft"
	//   "bottomRight"
	CornerPosition string `json:"cornerPosition,omitempty"`
	// Type: Defines the position type.
	//
	// Possible values:
	//   "corner"
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CornerPosition") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CornerPosition") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s InvideoPosition) MarshalJSON() ([]byte, error) {
	type NoMethod InvideoPosition
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// InvideoTiming: Describes a temporal position of a visual widget inside a
// video.
type InvideoTiming struct {
	// DurationMs: Defines the duration in milliseconds for which the promotion
	// should be displayed. If missing, the client should use the default.
	DurationMs uint64 `json:"durationMs,omitempty,string"`
	// OffsetMs: Defines the time at which the promotion will appear. Depending on
	// the value of type the value of the offsetMs field will represent a time
	// offset from the start or from the end of the video, expressed in
	// milliseconds.
	OffsetMs uint64 `json:"offsetMs,omitempty,string"`
	// Type: Describes a timing type. If the value is offsetFromStart, then the
	// offsetMs field represents an offset from the start of the video. If the
	// value is offsetFromEnd, then the offsetMs field represents an offset from
	// the end of the video.
	//
	// Possible values:
	//   "offsetFromStart"
	//   "offsetFromEnd"
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DurationMs") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DurationMs") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s InvideoTiming) MarshalJSON() ([]byte, error) {
	type NoMethod InvideoTiming
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LanguageTag struct {
	Value string `json:"value,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Value") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Value") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LanguageTag) MarshalJSON() ([]byte, error) {
	type NoMethod LanguageTag
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LevelDetails struct {
	// DisplayName: The name that should be used when referring to this level.
	DisplayName string `json:"displayName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DisplayName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DisplayName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LevelDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LevelDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcast: A *liveBroadcast* resource represents an event that will be
// streamed, via live video, on YouTube.
type LiveBroadcast struct {
	// ContentDetails: The contentDetails object contains information about the
	// event's video content, such as whether the content can be shown in an
	// embedded video player or if it will be archived and therefore available for
	// viewing after the event has concluded.
	ContentDetails *LiveBroadcastContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the broadcast.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveBroadcast".
	Kind string `json:"kind,omitempty"`
	// MonetizationDetails: The monetizationDetails object contains information
	// about the event's monetization details.
	MonetizationDetails *LiveBroadcastMonetizationDetails `json:"monetizationDetails,omitempty"`
	// Snippet: The snippet object contains basic details about the event,
	// including its title, description, start time, and end time.
	Snippet *LiveBroadcastSnippet `json:"snippet,omitempty"`
	// Statistics: The statistics object contains info about the event's current
	// stats. These include concurrent viewers and total chat count. Statistics can
	// change (in either direction) during the lifetime of an event. Statistics are
	// only returned while the event is live.
	Statistics *LiveBroadcastStatistics `json:"statistics,omitempty"`
	// Status: The status object contains information about the event's status.
	Status *LiveBroadcastStatus `json:"status,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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcast) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcast
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcastContentDetails: Detailed settings of a broadcast.
type LiveBroadcastContentDetails struct {
	// AvailabilityConfig: Optional. The broadcast's availability config. Used to
	// set specific region availability or block specific regions It is optional -
	// if not set, it is not enforced.
	AvailabilityConfig *AvailabilityConfig `json:"availabilityConfig,omitempty"`
	// BoundStreamId: This value uniquely identifies the `live stream`
	// (https://developers.google.com/youtube/data/live/reference/rest/v3/liveStreams)
	// bound to the broadcast.
	BoundStreamId string `json:"boundStreamId,omitempty"`
	// BoundStreamLastUpdateTimeMs: The date and time that the live stream
	// referenced by boundStreamId was last updated.
	BoundStreamLastUpdateTimeMs string `json:"boundStreamLastUpdateTimeMs,omitempty"`
	// Possible values:
	//   "closedCaptionsTypeUnspecified"
	//   "closedCaptionsDisabled"
	//   "closedCaptionsHttpPost"
	//   "closedCaptionsEmbedded"
	ClosedCaptionsType string `json:"closedCaptionsType,omitempty"`
	// EnableAutoStart: This setting indicates whether auto start is enabled for
	// this broadcast. The default value for this property is false. This setting
	// can only be used by Events.
	EnableAutoStart bool `json:"enableAutoStart,omitempty"`
	// EnableAutoStop: This setting indicates whether auto stop is enabled for this
	// broadcast. The default value for this property is false. This setting can
	// only be used by Events.
	EnableAutoStop bool `json:"enableAutoStop,omitempty"`
	// EnableClosedCaptions: This setting indicates whether HTTP POST closed
	// captioning is enabled for this broadcast. The ingestion URL of the closed
	// captions is returned through the liveStreams API. This is mutually exclusive
	// with using the closed_captions_type property, and is equivalent to setting
	// closed_captions_type to CLOSED_CAPTIONS_HTTP_POST.
	EnableClosedCaptions bool `json:"enableClosedCaptions,omitempty"`
	// EnableContentEncryption: This setting indicates whether YouTube should
	// enable content encryption for the broadcast.
	EnableContentEncryption bool `json:"enableContentEncryption,omitempty"`
	// EnableDvr: This setting determines whether viewers can access DVR controls
	// while watching the video. DVR controls enable the viewer to control the
	// video playback experience by pausing, rewinding, or fast forwarding content.
	// The default value for this property is true. *Important:* You must set the
	// value to true and also set the enableArchive property's value to true if you
	// want to make playback available immediately after the broadcast ends.
	EnableDvr bool `json:"enableDvr,omitempty"`
	// EnableEmbed: This setting indicates whether the broadcast video can be
	// played in an embedded player. If you choose to archive the video (using the
	// enableArchive property), this setting will also apply to the archived video.
	EnableEmbed bool `json:"enableEmbed,omitempty"`
	// EnableLowLatency: Indicates whether this broadcast has low latency enabled.
	EnableLowLatency bool `json:"enableLowLatency,omitempty"`
	// LatencyPreference: If both this and enable_low_latency are set, they must
	// match. LATENCY_NORMAL should match enable_low_latency=false LATENCY_LOW
	// should match enable_low_latency=true LATENCY_ULTRA_LOW should have
	// enable_low_latency omitted.
	//
	// Possible values:
	//   "latencyPreferenceUnspecified"
	//   "normal" - Best for: highest quality viewer playbacks and higher
	// resolutions.
	//   "low" - Best for: near real-time interaction, with minimal playback
	// buffering.
	//   "ultraLow" - Best for: real-time interaction Does not support: Closed
	// captions, 1440p, and 4k resolutions
	LatencyPreference string `json:"latencyPreference,omitempty"`
	// Mesh: The mesh for projecting the video if projection is mesh. The mesh
	// value must be a UTF-8 string containing the base-64 encoding of 3D mesh data
	// that follows the Spherical Video V2 RFC specification
	// (https://github.com/google/spatial-media/blob/master/docs/spherical-video-v2-rfc.md)
	// for an mshp box, excluding the box size and type but including the following
	// four reserved zero bytes for the version and flags.
	Mesh string `json:"mesh,omitempty"`
	// MonitorStream: The monitorStream object contains information about the
	// monitor stream, which the broadcaster can use to review the event content
	// before the broadcast stream is shown publicly.
	MonitorStream *MonitorStreamInfo `json:"monitorStream,omitempty"`
	// Projection: The projection format of this broadcast. This defaults to
	// rectangular.
	//
	// Possible values:
	//   "projectionUnspecified"
	//   "rectangular"
	//   "360"
	//   "mesh"
	Projection string `json:"projection,omitempty"`
	// RecordFromStart: Automatically start recording after the event goes live.
	// The default value for this property is true. *Important:* You must also set
	// the enableDvr property's value to true if you want the playback to be
	// available immediately after the broadcast ends. If you set this property's
	// value to true but do not also set the enableDvr property to true, there may
	// be a delay of around one day before the archived video will be available for
	// playback.
	RecordFromStart bool `json:"recordFromStart,omitempty"`
	// StartWithSlate: This setting indicates whether the broadcast should
	// automatically begin with an in-stream slate
	// (https://developers.google.com/youtube/data/live/getting-started#Displaying_Slates)
	// when you update the broadcast's status to live. After updating the status,
	// you then need to send a `liveCuepoints.insert`
	// (https://developers.google.com/youtube/data/live/reference/rest/v3/liveCuepoints/insert)
	// request that sets the cuepoint's eventState to end to remove the in-stream
	// slate and make your broadcast stream visible to viewers.
	StartWithSlate bool `json:"startWithSlate,omitempty"`
	// StereoLayout: The 3D stereo layout of this broadcast. This defaults to mono.
	//
	// Possible values:
	//   "stereoLayoutUnspecified"
	//   "mono"
	//   "leftRight"
	//   "topBottom"
	StereoLayout string `json:"stereoLayout,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AvailabilityConfig") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AvailabilityConfig") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveBroadcastListResponse 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 broadcasts that match the request criteria.
	Items []*LiveBroadcast `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveBroadcastListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcastMonetizationDetails: Monetization settings of a broadcast.
type LiveBroadcastMonetizationDetails struct {
	CuepointSchedule *CuepointSchedule `json:"cuepointSchedule,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CuepointSchedule") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CuepointSchedule") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastMonetizationDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastMonetizationDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcastSnippet: Basic broadcast information.
type LiveBroadcastSnippet struct {
	// ActualEndTime: The date and time that the broadcast actually ended. This
	// information is only available once the broadcast's state is complete.
	ActualEndTime string `json:"actualEndTime,omitempty"`
	// ActualStartTime: The date and time that the broadcast actually started. This
	// information is only available once the broadcast's state is live.
	ActualStartTime string `json:"actualStartTime,omitempty"`
	// CategoryId: The YouTube video category
	// (https://developers.google.com/youtube/data/reference/rest/v3/videoCategories/list)
	// associated with the video broadcast.
	CategoryId string `json:"categoryId,omitempty"`
	// ChannelId: The ID that YouTube uses to uniquely identify the channel that is
	// publishing the broadcast.
	ChannelId string `json:"channelId,omitempty"`
	// Description: The broadcast's description. As with the title, you can set
	// this field by modifying the broadcast resource or by setting the
	// `description`
	// (https://developers.google.com/youtube/data/reference/rest/v3/videos#snippet.description)
	// field of the corresponding video resource.
	Description string `json:"description,omitempty"`
	// IsDefaultBroadcast: Indicates whether this broadcast is the default
	// broadcast. Internal only.
	IsDefaultBroadcast bool `json:"isDefaultBroadcast,omitempty"`
	// LiveChatId: The id of the live chat for this broadcast.
	LiveChatId string `json:"liveChatId,omitempty"`
	// PublishedAt: The date and time that the broadcast was added to YouTube's
	// live broadcast schedule.
	PublishedAt string `json:"publishedAt,omitempty"`
	// ScheduledEndTime: The date and time that the broadcast is scheduled to end.
	ScheduledEndTime string `json:"scheduledEndTime,omitempty"`
	// ScheduledStartTime: The date and time that the broadcast is scheduled to
	// start.
	ScheduledStartTime string `json:"scheduledStartTime,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the broadcast. For
	// each nested object in this object, 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 broadcast's title. Note that the broadcast represents exactly one
	// YouTube video. You can set this field by modifying the broadcast resource or
	// by setting the `title`
	// (https://developers.google.com/youtube/data/reference/rest/v3/videos#snippet.title)
	// field of the corresponding video resource.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActualEndTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActualEndTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcastStatistics: Statistics about the live broadcast. These
// represent a snapshot of the values at the time of the request. Statistics
// are only returned for live broadcasts.
type LiveBroadcastStatistics struct {
	// ConcurrentViewers: The number of viewers currently watching the broadcast.
	// The property and its value will be present if the broadcast has current
	// viewers and the broadcast owner has not hidden the viewcount for the video.
	// Note that YouTube stops tracking the number of concurrent viewers for a
	// broadcast when the broadcast ends. So, this property would not identify the
	// number of viewers watching an archived video of a live broadcast that
	// already ended.
	ConcurrentViewers uint64 `json:"concurrentViewers,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "ConcurrentViewers") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ConcurrentViewers") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastStatistics) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastStatistics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveBroadcastStatus: Live broadcast state.
type LiveBroadcastStatus struct {
	// LifeCycleStatus: The broadcast's status. The status can be updated using the
	// API's `liveBroadcasts.transition`
	// (https://developers.google.com/youtube/data/live/reference/rest/v3/liveBroadcasts/transition)
	// method.
	//
	// Possible values:
	//   "lifeCycleStatusUnspecified" - No value or the value is unknown.
	//   "created" - Incomplete settings, but otherwise valid
	//   "ready" - Complete settings
	//   "testing" - Visible only to partner, may need special UI treatment
	//   "live" - Viper is recording; this means the "clock" is running
	//   "complete" - The broadcast is finished.
	//   "revoked" - This broadcast was removed by admin action
	//   "testStarting" - Transition into TESTING has been requested
	//   "liveStarting" - Transition into LIVE has been requested
	LifeCycleStatus string `json:"lifeCycleStatus,omitempty"`
	// LiveBroadcastPriority: Priority of the live broadcast event (internal
	// state).
	//
	// Possible values:
	//   "liveBroadcastPriorityUnspecified"
	//   "low" - Low priority broadcast: for low view count HoAs or other low
	// priority broadcasts.
	//   "normal" - Normal priority broadcast: for regular HoAs and broadcasts.
	//   "high" - High priority broadcast: for high profile HoAs, like PixelCorp
	// ones.
	LiveBroadcastPriority string `json:"liveBroadcastPriority,omitempty"`
	// MadeForKids: Whether the broadcast is made for kids or not, decided by
	// YouTube instead of the creator. This field is read only.
	MadeForKids bool `json:"madeForKids,omitempty"`
	// PrivacyStatus: The broadcast's privacy status. Note that the broadcast
	// represents exactly one YouTube video, so the privacy settings are identical
	// to those supported for videos. In addition, you can set this field by
	// modifying the broadcast resource or by setting the `privacyStatus`
	// (https://developers.google.com/youtube/data/reference/rest/v3/videos#status.privacyStatus)
	// field of the corresponding video resource.
	//
	// Possible values:
	//   "public"
	//   "unlisted"
	//   "private"
	PrivacyStatus string `json:"privacyStatus,omitempty"`
	// RecordingStatus: The broadcast's recording status.
	//
	// Possible values:
	//   "liveBroadcastRecordingStatusUnspecified" - No value or the value is
	// unknown.
	//   "notRecording" - The recording has not yet been started.
	//   "recording" - The recording is currently on.
	//   "recorded" - The recording is completed, and cannot be started again.
	RecordingStatus string `json:"recordingStatus,omitempty"`
	// SelfDeclaredMadeForKids: This field will be set to True if the creator
	// declares the broadcast to be kids only: go/live-cw-work.
	SelfDeclaredMadeForKids bool `json:"selfDeclaredMadeForKids,omitempty"`
	// ForceSendFields is a list of field names (e.g. "LifeCycleStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "LifeCycleStatus") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveBroadcastStatus) MarshalJSON() ([]byte, error) {
	type NoMethod LiveBroadcastStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveChatBan: A `__liveChatBan__` resource represents a ban for a YouTube
// live chat.
type LiveChatBan struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the ban.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveChatBan".
	Kind string `json:"kind,omitempty"`
	// Snippet: The `snippet` object contains basic details about the ban.
	Snippet *LiveChatBanSnippet `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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatBan) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatBan
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatBanSnippet struct {
	// BanDurationSeconds: The duration of a ban, only filled if the ban has type
	// TEMPORARY.
	BanDurationSeconds uint64                 `json:"banDurationSeconds,omitempty,string"`
	BannedUserDetails  *ChannelProfileDetails `json:"bannedUserDetails,omitempty"`
	// LiveChatId: The chat this ban is pertinent to.
	LiveChatId string `json:"liveChatId,omitempty"`
	// Type: The type of ban.
	//
	// Possible values:
	//   "liveChatBanTypeUnspecified" - An invalid ban type.
	//   "permanent" - A permanent ban.
	//   "temporary" - A temporary ban.
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BanDurationSeconds") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BanDurationSeconds") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatBanSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatBanSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatFanFundingEventDetails struct {
	// AmountDisplayString: A rendered string that displays the fund amount and
	// currency to the user.
	AmountDisplayString string `json:"amountDisplayString,omitempty"`
	// AmountMicros: The amount of the fund.
	AmountMicros uint64 `json:"amountMicros,omitempty,string"`
	// Currency: The currency in which the fund was made.
	Currency string `json:"currency,omitempty"`
	// UserComment: The comment added by the user to this fan funding event.
	UserComment string `json:"userComment,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountDisplayString") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountDisplayString") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatFanFundingEventDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatFanFundingEventDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveChatGiftDetails: Details about the gift event, this is only set if the
// type is `giftEvent`.
type LiveChatGiftDetails struct {
	// AltText: The alternative text to be used for accessibility.
	AltText string `json:"altText,omitempty"`
	// ComboCount: The number of times the gift has been sent in a row.
	ComboCount int64 `json:"comboCount,omitempty"`
	// GiftDuration: The duration of the gift.
	GiftDuration string `json:"giftDuration,omitempty"`
	// GiftName: The name of the gift.
	GiftName string `json:"giftName,omitempty"`
	// GiftUrl: The URL of the gift image.
	GiftUrl string `json:"giftUrl,omitempty"`
	// HasVisualEffect: Whether the gift involves a visual effect.
	HasVisualEffect bool `json:"hasVisualEffect,omitempty"`
	// JewelsAmount: The value of the gift in jewels.
	JewelsAmount int64 `json:"jewelsAmount,omitempty"`
	// Language: The BCP-47 language code of the gift.
	Language string `json:"language,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AltText") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AltText") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatGiftDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatGiftDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatGiftMembershipReceivedDetails struct {
	// AssociatedMembershipGiftingMessageId: The ID of the membership gifting
	// message that is related to this gift membership. This ID will always refer
	// to a message whose type is `membershipGiftingEvent`.
	AssociatedMembershipGiftingMessageId string `json:"associatedMembershipGiftingMessageId,omitempty"`
	// GifterChannelId: The ID of the user that made the membership gifting
	// purchase. This matches the `snippet.authorChannelId` of the associated
	// membership gifting message.
	GifterChannelId string `json:"gifterChannelId,omitempty"`
	// MemberLevelName: The name of the Level at which the viewer is a member. This
	// matches the `snippet.membershipGiftingDetails.giftMembershipsLevelName` of
	// the associated membership gifting message. The Level names are defined by
	// the YouTube channel offering the Membership. In some situations this field
	// isn't filled.
	MemberLevelName string `json:"memberLevelName,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "AssociatedMembershipGiftingMessageId") to unconditionally include in API
	// requests. By default, fields with empty or default values are omitted from
	// API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g.
	// "AssociatedMembershipGiftingMessageId") to include in API requests with the
	// JSON null value. By default, fields with empty values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-NullFields for
	// more details.
	NullFields []string `json:"-"`
}

func (s LiveChatGiftMembershipReceivedDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatGiftMembershipReceivedDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMemberMilestoneChatDetails struct {
	// MemberLevelName: The name of the Level at which the viever is a member. The
	// Level names are defined by the YouTube channel offering the Membership. In
	// some situations this field isn't filled.
	MemberLevelName string `json:"memberLevelName,omitempty"`
	// MemberMonth: The total amount of months (rounded up) the viewer has been a
	// member that granted them this Member Milestone Chat. This is the same number
	// of months as is being displayed to YouTube users.
	MemberMonth int64 `json:"memberMonth,omitempty"`
	// UserComment: The comment added by the member to this Member Milestone Chat.
	// This field is empty for messages without a comment from the member.
	UserComment string `json:"userComment,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MemberLevelName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MemberLevelName") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMemberMilestoneChatDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMemberMilestoneChatDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMembershipGiftingDetails struct {
	// GiftMembershipsCount: The number of gift memberships purchased by the user.
	GiftMembershipsCount int64 `json:"giftMembershipsCount,omitempty"`
	// GiftMembershipsLevelName: The name of the level of the gift memberships
	// purchased by the user. The Level names are defined by the YouTube channel
	// offering the Membership. In some situations this field isn't filled.
	GiftMembershipsLevelName string `json:"giftMembershipsLevelName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "GiftMembershipsCount") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "GiftMembershipsCount") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMembershipGiftingDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMembershipGiftingDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveChatMessage: A *liveChatMessage* resource represents a chat message in a
// YouTube Live Chat.
type LiveChatMessage struct {
	// AuthorDetails: The authorDetails object contains basic details about the
	// user that posted this message.
	AuthorDetails *LiveChatMessageAuthorDetails `json:"authorDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the message.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveChatMessage".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the message.
	Snippet *LiveChatMessageSnippet `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. "AuthorDetails") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AuthorDetails") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessage) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessage
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMessageAuthorDetails 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"`
	// IsChatModerator: Whether the author is a moderator of the live chat.
	IsChatModerator bool `json:"isChatModerator,omitempty"`
	// IsChatOwner: Whether the author is the owner of the live chat.
	IsChatOwner bool `json:"isChatOwner,omitempty"`
	// IsChatSponsor: Whether the author is a sponsor of the live chat.
	IsChatSponsor bool `json:"isChatSponsor,omitempty"`
	// IsVerified: Whether the author's identity has been verified by YouTube.
	IsVerified bool `json:"isVerified,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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessageAuthorDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessageAuthorDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMessageDeletedDetails struct {
	DeletedMessageId string `json:"deletedMessageId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DeletedMessageId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DeletedMessageId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessageDeletedDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessageDeletedDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMessageListResponse struct {
	// ActivePollItem: Set when there is an active poll.
	ActivePollItem *LiveChatMessage `json:"activePollItem,omitempty"`
	// 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   []*LiveChatMessage `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveChatMessageListResponse".
	Kind          string `json:"kind,omitempty"`
	NextPageToken string `json:"nextPageToken,omitempty"`
	// OfflineAt: The date and time when the underlying stream went offline.
	OfflineAt string `json:"offlineAt,omitempty"`
	// PageInfo: General pagination information.
	PageInfo *PageInfo `json:"pageInfo,omitempty"`
	// PollingIntervalMillis: The amount of time the client should wait before
	// polling again.
	PollingIntervalMillis int64            `json:"pollingIntervalMillis,omitempty"`
	TokenPagination       *TokenPagination `json:"tokenPagination,omitempty"`
	// 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. "ActivePollItem") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActivePollItem") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessageListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessageListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatMessageRetractedDetails struct {
	RetractedMessageId string `json:"retractedMessageId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "RetractedMessageId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RetractedMessageId") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessageRetractedDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessageRetractedDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveChatMessageSnippet: Next ID: 35
type LiveChatMessageSnippet struct {
	// AuthorChannelId: The ID of the user that authored this message, this field
	// is not always filled. textMessageEvent - the user that wrote the message
	// fanFundingEvent - the user that funded the broadcast newSponsorEvent - the
	// user that just became a sponsor memberMilestoneChatEvent - the member that
	// sent the message membershipGiftingEvent - the user that made the purchase
	// giftMembershipReceivedEvent - the user that received the gift membership
	// messageDeletedEvent - the moderator that took the action. Unused.
	// messageRetractedEvent - the author that retracted their message. Unused.
	// userBannedEvent - the moderator that took the action superChatEvent - the
	// user that made the purchase superStickerEvent - the user that made the
	// purchase pollEvent - the user that created the poll
	AuthorChannelId string `json:"authorChannelId,omitempty"`
	// DisplayMessage: Contains a string that can be displayed to the user. If this
	// field is not present the message is silent, at the moment only messages of
	// type TOMBSTONE and CHAT_ENDED_EVENT are silent.
	DisplayMessage string `json:"displayMessage,omitempty"`
	// FanFundingEventDetails: Details about the funding event, this is only set if
	// the type is `fanFundingEvent`.
	FanFundingEventDetails *LiveChatFanFundingEventDetails `json:"fanFundingEventDetails,omitempty"`
	// GiftDetails: Details about the gift event, this is only set if the type is
	// `giftEvent`.
	GiftDetails *LiveChatGiftDetails `json:"giftDetails,omitempty"`
	// GiftMembershipReceivedDetails: Details about the Gift Membership Received
	// event, this is only set if the type is `giftMembershipReceivedEvent`.
	GiftMembershipReceivedDetails *LiveChatGiftMembershipReceivedDetails `json:"giftMembershipReceivedDetails,omitempty"`
	// HasDisplayContent: Whether the message has display content that should be
	// displayed to users.
	HasDisplayContent bool   `json:"hasDisplayContent,omitempty"`
	LiveChatId        string `json:"liveChatId,omitempty"`
	// MemberMilestoneChatDetails: Details about the Member Milestone Chat event,
	// this is only set if the type is `memberMilestoneChatEvent`.
	MemberMilestoneChatDetails *LiveChatMemberMilestoneChatDetails `json:"memberMilestoneChatDetails,omitempty"`
	// MembershipGiftingDetails: Details about the Membership Gifting event, this
	// is only set if the type is `membershipGiftingEvent`.
	MembershipGiftingDetails *LiveChatMembershipGiftingDetails `json:"membershipGiftingDetails,omitempty"`
	MessageDeletedDetails    *LiveChatMessageDeletedDetails    `json:"messageDeletedDetails,omitempty"`
	MessageRetractedDetails  *LiveChatMessageRetractedDetails  `json:"messageRetractedDetails,omitempty"`
	// NewSponsorDetails: Details about the New Member Announcement event, this is
	// only set if the type is `newSponsorEvent`. The term "member" replaces
	// "sponsor".
	NewSponsorDetails *LiveChatNewSponsorDetails `json:"newSponsorDetails,omitempty"`
	// PollDetails: Details about the poll event, this is only set if the type is
	// `pollEvent`.
	PollDetails *LiveChatPollDetails `json:"pollDetails,omitempty"`
	// PublishedAt: The date and time when the message was orignally published.
	PublishedAt string `json:"publishedAt,omitempty"`
	// SuperChatDetails: Details about the Super Chat event, this is only set if
	// the type is `superChatEvent`.
	SuperChatDetails *LiveChatSuperChatDetails `json:"superChatDetails,omitempty"`
	// SuperStickerDetails: Details about the Super Sticker event, this is only set
	// if the type is `superStickerEvent`.
	SuperStickerDetails *LiveChatSuperStickerDetails `json:"superStickerDetails,omitempty"`
	// TextMessageDetails: Details about the text message, this is only set if the
	// type is `textMessageEvent`.
	TextMessageDetails *LiveChatTextMessageDetails `json:"textMessageDetails,omitempty"`
	// Type: The type of message, this will always be present, it determines the
	// contents of the message as well as which fields will be present.
	//
	// Possible values:
	//   "invalidType"
	//   "textMessageEvent"
	//   "tombstone"
	//   "fanFundingEvent"
	//   "chatEndedEvent"
	//   "sponsorOnlyModeStartedEvent"
	//   "sponsorOnlyModeEndedEvent"
	//   "newSponsorEvent"
	//   "memberMilestoneChatEvent"
	//   "membershipGiftingEvent"
	//   "giftMembershipReceivedEvent"
	//   "messageDeletedEvent"
	//   "messageRetractedEvent"
	//   "userBannedEvent"
	//   "superChatEvent"
	//   "superStickerEvent"
	//   "pollEvent"
	//   "giftEvent" - A virtual gift sent by a viewer to support a creator.
	Type              string                            `json:"type,omitempty"`
	UserBannedDetails *LiveChatUserBannedMessageDetails `json:"userBannedDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AuthorChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AuthorChannelId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatMessageSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatMessageSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveChatModerator: A *liveChatModerator* resource represents a moderator for
// a YouTube live chat. A chat moderator has the ability to ban/unban users
// from a chat, remove message, etc.
type LiveChatModerator struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the moderator.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveChatModerator".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the moderator.
	Snippet *LiveChatModeratorSnippet `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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatModerator) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatModerator
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatModeratorListResponse 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 moderators that match the request criteria.
	Items []*LiveChatModerator `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveChatModeratorListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatModeratorListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatModeratorListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatModeratorSnippet struct {
	// LiveChatId: The ID of the live chat this moderator can act on.
	LiveChatId string `json:"liveChatId,omitempty"`
	// ModeratorDetails: Details about the moderator.
	ModeratorDetails *ChannelProfileDetails `json:"moderatorDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "LiveChatId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "LiveChatId") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatModeratorSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatModeratorSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatNewSponsorDetails struct {
	// IsUpgrade: If the viewer just had upgraded from a lower level. For viewers
	// that were not members at the time of purchase, this field is false.
	IsUpgrade bool `json:"isUpgrade,omitempty"`
	// MemberLevelName: The name of the Level that the viewer just had joined. The
	// Level names are defined by the YouTube channel offering the Membership. In
	// some situations this field isn't filled.
	MemberLevelName string `json:"memberLevelName,omitempty"`
	// ForceSendFields is a list of field names (e.g. "IsUpgrade") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "IsUpgrade") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatNewSponsorDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatNewSponsorDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatPollDetails struct {
	Metadata *LiveChatPollDetailsPollMetadata `json:"metadata,omitempty"`
	// Possible values:
	//   "unknown"
	//   "active"
	//   "closed"
	Status string `json:"status,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Metadata") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Metadata") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatPollDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatPollDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatPollDetailsPollMetadata struct {
	// Options: The options will be returned in the order that is displayed in 1P
	Options      []*LiveChatPollDetailsPollMetadataPollOption `json:"options,omitempty"`
	QuestionText string                                       `json:"questionText,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Options") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Options") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatPollDetailsPollMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatPollDetailsPollMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatPollDetailsPollMetadataPollOption struct {
	OptionText string `json:"optionText,omitempty"`
	Tally      int64  `json:"tally,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "OptionText") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "OptionText") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatPollDetailsPollMetadataPollOption) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatPollDetailsPollMetadataPollOption
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatSuperChatDetails struct {
	// AmountDisplayString: A rendered string that displays the fund amount and
	// currency to the user.
	AmountDisplayString string `json:"amountDisplayString,omitempty"`
	// AmountMicros: The amount purchased by the user, in micros (1,750,000 micros
	// = 1.75).
	AmountMicros uint64 `json:"amountMicros,omitempty,string"`
	// Currency: The currency in which the purchase was made.
	Currency string `json:"currency,omitempty"`
	// Tier: The tier in which the amount belongs. Lower amounts belong to lower
	// tiers. The lowest tier is `1`.
	Tier int64 `json:"tier,omitempty"`
	// UserComment: The comment added by the user to this Super Chat event.
	UserComment string `json:"userComment,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountDisplayString") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountDisplayString") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatSuperChatDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatSuperChatDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatSuperStickerDetails struct {
	// AmountDisplayString: A rendered string that displays the fund amount and
	// currency to the user.
	AmountDisplayString string `json:"amountDisplayString,omitempty"`
	// AmountMicros: The amount purchased by the user, in micros (1,750,000 micros
	// = 1.75).
	AmountMicros uint64 `json:"amountMicros,omitempty,string"`
	// Currency: The currency in which the purchase was made.
	Currency string `json:"currency,omitempty"`
	// SuperStickerMetadata: Information about the Super Sticker.
	SuperStickerMetadata *SuperStickerMetadata `json:"superStickerMetadata,omitempty"`
	// Tier: The tier in which the amount belongs. Lower amounts belong to lower
	// tiers. The lowest tier is `1`.
	Tier int64 `json:"tier,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountDisplayString") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountDisplayString") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatSuperStickerDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatSuperStickerDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatTextMessageDetails struct {
	// MessageText: The user's message.
	MessageText string `json:"messageText,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MessageText") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MessageText") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatTextMessageDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatTextMessageDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveChatUserBannedMessageDetails struct {
	// BanDurationSeconds: The duration of the ban. This property is only present
	// if the `banType` is `temporary`.
	BanDurationSeconds uint64 `json:"banDurationSeconds,omitempty,string"`
	// BanType: The type of ban.
	//
	// Possible values:
	//   "permanent"
	//   "temporary"
	BanType string `json:"banType,omitempty"`
	// BannedUserDetails: The details of the user that was banned.
	BannedUserDetails *ChannelProfileDetails `json:"bannedUserDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BanDurationSeconds") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BanDurationSeconds") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveChatUserBannedMessageDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveChatUserBannedMessageDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveStream: A live stream describes a live ingestion point.
type LiveStream struct {
	// Cdn: The cdn object defines the live stream's content delivery network (CDN)
	// settings. These settings provide details about the manner in which you
	// stream your content to YouTube.
	Cdn *CdnSettings `json:"cdn,omitempty"`
	// ContentDetails: The content_details object contains information about the
	// stream, including the closed captions ingestion URL.
	ContentDetails *LiveStreamContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the stream.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveStream".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the stream,
	// including its channel, title, and description.
	Snippet *LiveStreamSnippet `json:"snippet,omitempty"`
	// Status: The status object contains information about live stream's status.
	Status *LiveStreamStatus `json:"status,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Cdn") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Cdn") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStream) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStream
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveStreamConfigurationIssue struct {
	// Description: The long-form description of the issue and how to resolve it.
	Description string `json:"description,omitempty"`
	// Reason: The short-form reason for this issue.
	Reason string `json:"reason,omitempty"`
	// Severity: How severe this issue is to the stream.
	//
	// Possible values:
	//   "info"
	//   "warning"
	//   "error"
	Severity string `json:"severity,omitempty"`
	// Type: The kind of error happening.
	//
	// Possible values:
	//   "gopSizeOver"
	//   "gopSizeLong"
	//   "gopSizeShort"
	//   "openGop"
	//   "badContainer"
	//   "audioBitrateHigh"
	//   "audioBitrateLow"
	//   "audioSampleRate"
	//   "bitrateHigh"
	//   "bitrateLow"
	//   "audioCodec"
	//   "videoCodec"
	//   "noAudioStream"
	//   "noVideoStream"
	//   "multipleVideoStreams"
	//   "multipleAudioStreams"
	//   "audioTooManyChannels"
	//   "interlacedVideo"
	//   "frameRateHigh"
	//   "resolutionMismatch"
	//   "videoCodecMismatch"
	//   "videoInterlaceMismatch"
	//   "videoProfileMismatch"
	//   "videoBitrateMismatch"
	//   "framerateMismatch"
	//   "gopMismatch"
	//   "audioSampleRateMismatch"
	//   "audioStereoMismatch"
	//   "audioCodecMismatch"
	//   "audioBitrateMismatch"
	//   "videoResolutionSuboptimal"
	//   "videoResolutionUnsupported"
	//   "videoIngestionStarved"
	//   "videoIngestionFasterThanRealtime"
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Description") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamConfigurationIssue) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamConfigurationIssue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveStreamContentDetails: Detailed settings of a stream.
type LiveStreamContentDetails struct {
	// ClosedCaptionsIngestionUrl: The ingestion URL where the closed captions of
	// this stream are sent.
	ClosedCaptionsIngestionUrl string `json:"closedCaptionsIngestionUrl,omitempty"`
	// IsReusable: Indicates whether the stream is reusable, which means that it
	// can be bound to multiple broadcasts. It is common for broadcasters to reuse
	// the same stream for many different broadcasts if those broadcasts occur at
	// different times. If you set this value to false, then the stream will not be
	// reusable, which means that it can only be bound to one broadcast.
	// Non-reusable streams differ from reusable streams in the following ways: * A
	// non-reusable stream can only be bound to one broadcast. * A non-reusable
	// stream might be deleted by an automated process after the broadcast ends. *
	// The `liveStreams.list`
	// (https://developers.google.com/youtube/data/live/reference/rest/v3/liveStreams/list)
	// method does not list non-reusable streams if you call the method and set the
	// mine parameter to true. The only way to use that method to retrieve the
	// resource for a non-reusable stream is to use the id parameter to identify
	// the stream.
	IsReusable bool `json:"isReusable,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ClosedCaptionsIngestionUrl")
	// to unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ClosedCaptionsIngestionUrl") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveStreamHealthStatus struct {
	// ConfigurationIssues: The configurations issues on this stream
	ConfigurationIssues []*LiveStreamConfigurationIssue `json:"configurationIssues,omitempty"`
	// LastUpdateTimeSeconds: The last time this status was updated (in seconds)
	LastUpdateTimeSeconds uint64 `json:"lastUpdateTimeSeconds,omitempty,string"`
	// Status: The status code of this stream
	//
	// Possible values:
	//   "good"
	//   "ok"
	//   "bad"
	//   "noData"
	//   "revoked"
	Status string `json:"status,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ConfigurationIssues") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ConfigurationIssues") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamHealthStatus) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamHealthStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveStreamListResponse 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 live streams that match the request criteria.
	Items []*LiveStream `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#liveStreamListResponse".
	Kind string `json:"kind,omitempty"`
	// NextPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the next page in the result set.
	NextPageToken string    `json:"nextPageToken,omitempty"`
	PageInfo      *PageInfo `json:"pageInfo,omitempty"`
	// PrevPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the previous page in the result set.
	PrevPageToken   string           `json:"prevPageToken,omitempty"`
	TokenPagination *TokenPagination `json:"tokenPagination,omitempty"`
	// VisitorId: The visitorId identifies the visitor.
	VisitorId string `json:"visitorId,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LiveStreamSnippet struct {
	// ChannelId: The ID that YouTube uses to uniquely identify the channel that is
	// transmitting the stream.
	ChannelId string `json:"channelId,omitempty"`
	// Description: The stream's description. The value cannot be longer than 10000
	// characters.
	Description     string `json:"description,omitempty"`
	IsDefaultStream bool   `json:"isDefaultStream,omitempty"`
	// PublishedAt: The date and time that the stream was created.
	PublishedAt string `json:"publishedAt,omitempty"`
	// Title: The stream's title. The value must be between 1 and 128 characters
	// long.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// LiveStreamStatus: Brief description of the live stream status.
type LiveStreamStatus struct {
	// HealthStatus: The health status of the stream.
	HealthStatus *LiveStreamHealthStatus `json:"healthStatus,omitempty"`
	// Possible values:
	//   "created"
	//   "ready"
	//   "active"
	//   "inactive"
	//   "error"
	StreamStatus string `json:"streamStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HealthStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HealthStatus") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LiveStreamStatus) MarshalJSON() ([]byte, error) {
	type NoMethod LiveStreamStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LocalizedProperty struct {
	Default string `json:"default,omitempty"`
	// DefaultLanguage: The language of the default property.
	DefaultLanguage *LanguageTag       `json:"defaultLanguage,omitempty"`
	Localized       []*LocalizedString `json:"localized,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Default") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Default") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LocalizedProperty) MarshalJSON() ([]byte, error) {
	type NoMethod LocalizedProperty
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type LocalizedString struct {
	Language string `json:"language,omitempty"`
	Value    string `json:"value,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Language") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Language") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s LocalizedString) MarshalJSON() ([]byte, error) {
	type NoMethod LocalizedString
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Member: A *member* resource represents a member for a YouTube channel. A
// member provides recurring monetary support to a creator and receives special
// benefits.
type Member struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#member".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the member.
	Snippet *MemberSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Member) MarshalJSON() ([]byte, error) {
	type NoMethod Member
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MemberListResponse 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 members that match the request criteria.
	Items []*Member `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#memberListResponse".
	Kind string `json:"kind,omitempty"`
	// NextPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the next page in the result set.
	NextPageToken   string           `json:"nextPageToken,omitempty"`
	PageInfo        *PageInfo        `json:"pageInfo,omitempty"`
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MemberListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod MemberListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MemberSnippet struct {
	// CreatorChannelId: The id of the channel that's offering memberships.
	CreatorChannelId string `json:"creatorChannelId,omitempty"`
	// MemberDetails: Details about the member.
	MemberDetails *ChannelProfileDetails `json:"memberDetails,omitempty"`
	// MembershipsDetails: Details about the user's membership.
	MembershipsDetails *MembershipsDetails `json:"membershipsDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CreatorChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CreatorChannelId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MemberSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod MemberSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MembershipsDetails struct {
	// AccessibleLevels: Ids of all levels that the user has access to. This
	// includes the currently active level and all other levels that are included
	// because of a higher purchase.
	AccessibleLevels []string `json:"accessibleLevels,omitempty"`
	// HighestAccessibleLevel: Id of the highest level that the user has access to
	// at the moment.
	HighestAccessibleLevel string `json:"highestAccessibleLevel,omitempty"`
	// HighestAccessibleLevelDisplayName: Display name for the highest level that
	// the user has access to at the moment.
	HighestAccessibleLevelDisplayName string `json:"highestAccessibleLevelDisplayName,omitempty"`
	// MembershipsDuration: Data about memberships duration without taking into
	// consideration pricing levels.
	MembershipsDuration *MembershipsDuration `json:"membershipsDuration,omitempty"`
	// MembershipsDurationAtLevels: Data about memberships duration on particular
	// pricing levels.
	MembershipsDurationAtLevels []*MembershipsDurationAtLevel `json:"membershipsDurationAtLevels,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AccessibleLevels") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AccessibleLevels") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsDetails) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MembershipsDuration struct {
	// MemberSince: The date and time when the user became a continuous member
	// across all levels.
	MemberSince string `json:"memberSince,omitempty"`
	// MemberTotalDurationMonths: The cumulative time the user has been a member
	// across all levels in complete months (the time is rounded down to the
	// nearest integer).
	MemberTotalDurationMonths int64 `json:"memberTotalDurationMonths,omitempty"`
	// ForceSendFields is a list of field names (e.g. "MemberSince") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "MemberSince") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsDuration) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsDuration
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MembershipsDurationAtLevel struct {
	// Level: Pricing level ID.
	Level string `json:"level,omitempty"`
	// MemberSince: The date and time when the user became a continuous member for
	// the given level.
	MemberSince string `json:"memberSince,omitempty"`
	// MemberTotalDurationMonths: The cumulative time the user has been a member
	// for the given level in complete months (the time is rounded down to the
	// nearest integer).
	MemberTotalDurationMonths int64 `json:"memberTotalDurationMonths,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Level") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Level") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsDurationAtLevel) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsDurationAtLevel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// MembershipsLevel: A *membershipsLevel* resource represents an offer made by
// YouTube creators for their fans. Users can become members of the channel by
// joining one of the available levels. They will provide recurring monetary
// support and receives special benefits.
type MembershipsLevel struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the memberships level.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#membershipsLevelListResponse".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the level.
	Snippet *MembershipsLevelSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsLevel) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsLevel
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MembershipsLevelListResponse 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 pricing levels offered by a creator to the fans.
	Items []*MembershipsLevel `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#membershipsLevelListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsLevelListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsLevelListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type MembershipsLevelSnippet struct {
	// CreatorChannelId: The id of the channel that's offering channel memberships.
	CreatorChannelId string `json:"creatorChannelId,omitempty"`
	// LevelDetails: Details about the pricing level.
	LevelDetails *LevelDetails `json:"levelDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CreatorChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CreatorChannelId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MembershipsLevelSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod MembershipsLevelSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// MonitorStreamInfo: Settings and Info of the monitor stream
type MonitorStreamInfo struct {
	// BroadcastStreamDelayMs: If you have set the `enableMonitorStream`
	// (https://developers.google.com/youtube/data/live/reference/rest/v3/liveBroadcasts#contentDetails.monitorStream.enableMonitorStream)
	// property to true, then this property determines the length of the live
	// broadcast delay.
	BroadcastStreamDelayMs int64 `json:"broadcastStreamDelayMs,omitempty"`
	// EmbedHtml: HTML code that embeds a player that plays the monitor stream.
	EmbedHtml string `json:"embedHtml,omitempty"`
	// EnableMonitorStream: This value determines whether the monitor stream is
	// enabled for the broadcast. If the monitor stream is enabled, then YouTube
	// will broadcast the event content on a special stream intended only for the
	// broadcaster's consumption. The broadcaster can use the stream to review the
	// event content and also to identify the optimal times to insert cuepoints.
	// You need to set this value to true if you intend to have a broadcast delay
	// for your event. *Note:* This property cannot be updated once the broadcast
	// is in the testing or live state.
	EnableMonitorStream *bool `json:"enableMonitorStream,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BroadcastStreamDelayMs") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BroadcastStreamDelayMs") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s MonitorStreamInfo) MarshalJSON() ([]byte, error) {
	type NoMethod MonitorStreamInfo
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PageInfo: Paging details for lists of resources, including total number of
// items available and number of resources returned in a single page.
type PageInfo struct {
	// ResultsPerPage: The number of results included in the API response.
	ResultsPerPage int64 `json:"resultsPerPage,omitempty"`
	// TotalResults: The total number of results in the result set.
	TotalResults int64 `json:"totalResults,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ResultsPerPage") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ResultsPerPage") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PageInfo) MarshalJSON() ([]byte, error) {
	type NoMethod PageInfo
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Playlist: A *playlist* resource represents a YouTube playlist. A playlist is
// a collection of videos that can be viewed sequentially and shared with other
// users. A playlist can contain up to 200 videos, and YouTube does not limit
// the number of playlists that each user creates. By default, playlists are
// publicly visible to other users, but playlists can be public or private.
// YouTube also uses playlists to identify special collections of videos for a
// channel, such as: * uploaded videos * favorite videos * positively rated
// (liked) videos * watch history * watch later To be more specific, these
// lists are associated with a channel, which is a collection of a person,
// group, or company's videos, playlists, and other YouTube information. You
// can retrieve the playlist IDs for each of these lists from the `channel
// resource`
// (https://developers.google.com/youtube/data/reference/rest/v3/channels) for
// a given channel. You can then use the `playlistItems.list`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/list)
// method to retrieve any of those lists. You can also add or remove items from
// those lists by calling the `playlistItems.insert`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
// and `playlistItems.delete`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/delete)
// methods.
type Playlist struct {
	// ContentDetails: The contentDetails object contains information like video
	// count.
	ContentDetails *PlaylistContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the playlist.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlist".
	Kind string `json:"kind,omitempty"`
	// Localizations: Localizations for different languages
	Localizations map[string]PlaylistLocalization `json:"localizations,omitempty"`
	// Player: The player object contains information that you would use to play
	// the playlist in an embedded player.
	Player *PlaylistPlayer `json:"player,omitempty"`
	// Snippet: The snippet object contains basic details about the playlist, such
	// as its title and description.
	Snippet *PlaylistSnippet `json:"snippet,omitempty"`
	// Status: The status object contains status information for the playlist.
	Status *PlaylistStatus `json:"status,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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Playlist) MarshalJSON() ([]byte, error) {
	type NoMethod Playlist
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistContentDetails struct {
	// ItemCount: The number of videos in the playlist.
	ItemCount int64 `json:"itemCount,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ItemCount") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ItemCount") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistImage struct {
	// Id: Identifies this resource (playlist id and image type).
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlistImages".
	Kind    string                `json:"kind,omitempty"`
	Snippet *PlaylistImageSnippet `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. "Id") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistImage) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistImage
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistImageListResponse struct {
	Items []*PlaylistImage `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlistImageListResponse".
	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"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Items") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Items") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistImageListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistImageListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistImageSnippet: A *playlistImage* resource identifies another
// resource, such as a image, that is associated with a playlist. In addition,
// the playlistImage resource contains details about the included resource that
// pertain specifically to how that resource is used in that playlist. YouTube
// uses playlists to identify special collections of videos for a channel, such
// as: * uploaded videos * favorite videos * positively rated (liked) videos *
// watch history To be more specific, these lists are associated with a
// channel, which is a collection of a person, group, or company's videos,
// playlists, and other YouTube information. You can retrieve the playlist IDs
// for each of these lists from the `channel resource`
// (https://developers.google.com/youtube/data/reference/rest/v3/channels) for
// a given channel. You can then use the `playlistImages.list`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistImages/list)
// method to retrieve image data for any of those playlists. You can also add
// or remove images from those lists by calling the `playlistImages.insert`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistImages/insert)
// and `playlistImages.delete`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistImages/delete)
// methods.
type PlaylistImageSnippet struct {
	// Height: The image height.
	Height int64 `json:"height,omitempty"`
	// PlaylistId: The Playlist ID of the playlist this image is associated with.
	PlaylistId string `json:"playlistId,omitempty"`
	// Type: The image type.
	//
	// Possible values:
	//   "hero" - The main image that will be used for this playlist.
	Type string `json:"type,omitempty"`
	// Width: The image width.
	Width int64 `json:"width,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Height") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Height") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistImageSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistImageSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistItem: A *playlistItem* resource identifies another resource, such as
// a video, that is included in a playlist. In addition, the playlistItem
// resource contains details about the included resource that pertain
// specifically to how that resource is used in that playlist. YouTube uses
// playlists to identify special collections of videos for a channel, such as:
// * uploaded videos * favorite videos * positively rated (liked) videos *
// watch history * watch later To be more specific, these lists are associated
// with a channel, which is a collection of a person, group, or company's
// videos, playlists, and other YouTube information. You can retrieve the
// playlist IDs for each of these lists from the `channel resource`
// (https://developers.google.com/youtube/data/reference/rest/v3/channels) for
// a given channel. You can then use the `playlistItems.list`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/list)
// method to retrieve any of those lists. You can also add or remove items from
// those lists by calling the `playlistItems.insert`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/insert)
// and `playlistItems.delete`
// (https://developers.google.com/youtube/data/reference/rest/v3/playlistItems/delete)
// methods. For example, if a user gives a positive rating to a video, you
// would insert that video into the liked videos playlist for that user's
// channel.
type PlaylistItem struct {
	// ContentDetails: The contentDetails object is included in the resource if the
	// included item is a YouTube video. The object contains additional information
	// about the video.
	ContentDetails *PlaylistItemContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the playlist item.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlistItem".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the playlist item,
	// such as its title and position in the playlist.
	Snippet *PlaylistItemSnippet `json:"snippet,omitempty"`
	// Status: The status object contains information about the playlist item's
	// privacy status.
	Status *PlaylistItemStatus `json:"status,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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistItem) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistItem
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistItemContentDetails struct {
	// EndAt: The time, measured in seconds from the start of the video, when the
	// video should stop playing. (The playlist owner can specify the times when
	// the video should start and stop playing when the video is played in the
	// context of the playlist.) By default, assume that the video.endTime is the
	// end of the video.
	EndAt string `json:"endAt,omitempty"`
	// Note: A user-generated note for this item.
	Note string `json:"note,omitempty"`
	// StartAt: The time, measured in seconds from the start of the video, when the
	// video should start playing. (The playlist owner can specify the times when
	// the video should start and stop playing when the video is played in the
	// context of the playlist.) The default value is 0.
	StartAt string `json:"startAt,omitempty"`
	// VideoId: The ID that YouTube uses to uniquely identify a video. To retrieve
	// the `video` resource
	// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list),
	// set the id query parameter to this value in your API request.
	VideoId string `json:"videoId,omitempty"`
	// VideoPublishedAt: The date and time that the video was published to YouTube.
	VideoPublishedAt string `json:"videoPublishedAt,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EndAt") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EndAt") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistItemContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistItemContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistItemListResponse struct {
	Etag string `json:"etag,omitempty"`
	// EventId: Serialized EventId of the request which produced this response.
	EventId string `json:"eventId,omitempty"`
	// Items: A list of playlist items that match the request criteria.
	Items []*PlaylistItem `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlistItemListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistItemListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistItemListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistItemSnippet: Basic details about a playlist, including title,
// description and thumbnails. Basic details of a YouTube Playlist item
// provided by the author. Next ID: 15
type PlaylistItemSnippet struct {
	// ChannelId: The ID that YouTube uses to uniquely identify the user that added
	// the item to the playlist.
	ChannelId string `json:"channelId,omitempty"`
	// ChannelTitle: Channel title for the channel that the playlist item belongs
	// to.
	ChannelTitle string `json:"channelTitle,omitempty"`
	// Description: The item's description.
	Description string `json:"description,omitempty"`
	// PlaylistId: The ID that YouTube uses to uniquely identify thGe playlist that
	// the playlist item is in.
	PlaylistId string `json:"playlistId,omitempty"`
	// Position: The order in which the item appears in the playlist. The value
	// uses a zero-based index, so the first item has a position of 0, the second
	// item has a position of 1, and so forth.
	Position int64 `json:"position,omitempty"`
	// PublishedAt: The date and time that the item was added to the playlist.
	PublishedAt string `json:"publishedAt,omitempty"`
	// ResourceId: The id object contains information that can be used to uniquely
	// identify the resource that is included in the playlist as the playlist item.
	ResourceId *ResourceId `json:"resourceId,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the playlist item. 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 item's title.
	Title string `json:"title,omitempty"`
	// VideoOwnerChannelId: Channel id for the channel this video belongs to.
	VideoOwnerChannelId string `json:"videoOwnerChannelId,omitempty"`
	// VideoOwnerChannelTitle: Channel title for the channel this video belongs to.
	VideoOwnerChannelTitle string `json:"videoOwnerChannelTitle,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistItemSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistItemSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistItemStatus: Information about the playlist item's privacy status.
type PlaylistItemStatus struct {
	// PrivacyStatus: This resource's privacy status.
	//
	// Possible values:
	//   "public"
	//   "unlisted"
	//   "private"
	PrivacyStatus string `json:"privacyStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "PrivacyStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "PrivacyStatus") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistItemStatus) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistItemStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistListResponse 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 playlists that match the request criteria
	Items []*Playlist `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#playlistListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistLocalization: Playlist localization setting
type PlaylistLocalization struct {
	// Description: The localized strings for playlist's description.
	Description string `json:"description,omitempty"`
	// Title: The localized strings for playlist'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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistLocalization) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistLocalization
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistPlayer struct {
	// EmbedHtml: An <iframe> tag that embeds a player that will play the playlist.
	EmbedHtml string `json:"embedHtml,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EmbedHtml") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EmbedHtml") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistPlayer) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistPlayer
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PlaylistSnippet: Basic details about a playlist, including title,
// description and thumbnails.
type PlaylistSnippet struct {
	// ChannelId: The ID that YouTube uses to uniquely identify the channel that
	// published the playlist.
	ChannelId string `json:"channelId,omitempty"`
	// ChannelTitle: The channel title of the channel that the video belongs to.
	ChannelTitle string `json:"channelTitle,omitempty"`
	// DefaultLanguage: The language of the playlist's default title and
	// description.
	DefaultLanguage string `json:"defaultLanguage,omitempty"`
	// Description: The playlist's description.
	Description string `json:"description,omitempty"`
	// Localized: Localized title and description, read-only.
	Localized *PlaylistLocalization `json:"localized,omitempty"`
	// PublishedAt: The date and time that the playlist was created.
	PublishedAt string `json:"publishedAt,omitempty"`
	// Tags: Keyword tags associated with the playlist.
	Tags []string `json:"tags,omitempty"`
	// ThumbnailVideoId: Note: if the playlist has a custom thumbnail, this field
	// will not be populated. The video id selected by the user that will be used
	// as the thumbnail of this playlist. This field defaults to the first publicly
	// viewable video in the playlist, if: 1. The user has never selected a video
	// to be the thumbnail of the playlist. 2. The user selects a video to be the
	// thumbnail, and then removes that video from the playlist. 3. The user
	// selects a non-owned video to be the thumbnail, but that video becomes
	// private, or gets deleted.
	ThumbnailVideoId string `json:"thumbnailVideoId,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the playlist. 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 playlist's title.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type PlaylistStatus struct {
	// PodcastStatus: The playlist's podcast status.
	//
	// Possible values:
	//   "enabled"
	//   "disabled"
	PodcastStatus string `json:"podcastStatus,omitempty"`
	// PrivacyStatus: The playlist's privacy status.
	//
	// Possible values:
	//   "public"
	//   "unlisted"
	//   "private"
	PrivacyStatus string `json:"privacyStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "PodcastStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "PodcastStatus") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PlaylistStatus) MarshalJSON() ([]byte, error) {
	type NoMethod PlaylistStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// PropertyValue: A pair Property / Value.
type PropertyValue struct {
	// Property: A property.
	Property string `json:"property,omitempty"`
	// Value: The property's value.
	Value string `json:"value,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Property") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Property") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s PropertyValue) MarshalJSON() ([]byte, error) {
	type NoMethod PropertyValue
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type RelatedEntity struct {
	Entity *Entity `json:"entity,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Entity") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Entity") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s RelatedEntity) MarshalJSON() ([]byte, error) {
	type NoMethod RelatedEntity
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ResourceId: A resource id is a generic reference that points to another
// YouTube resource.
type ResourceId struct {
	// ChannelId: The ID that YouTube uses to uniquely identify the referred
	// resource, if that resource is a channel. This property is only present if
	// the resourceId.kind value is youtube#channel.
	ChannelId string `json:"channelId,omitempty"`
	// Kind: The type of the API resource.
	Kind string `json:"kind,omitempty"`
	// PlaylistId: The ID that YouTube uses to uniquely identify the referred
	// resource, if that resource is a playlist. This property is only present if
	// the resourceId.kind value is youtube#playlist.
	PlaylistId string `json:"playlistId,omitempty"`
	// VideoId: The ID that YouTube uses to uniquely identify the referred
	// resource, if that resource is a video. This property is only present if the
	// resourceId.kind value is youtube#video.
	VideoId string `json:"videoId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ResourceId) MarshalJSON() ([]byte, error) {
	type NoMethod ResourceId
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type SearchListResponse 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: Pagination information for token pagination.
	Items []*SearchResult `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#searchListResponse".
	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"`
	RegionCode      string           `json:"regionCode,omitempty"`
	TokenPagination *TokenPagination `json:"tokenPagination,omitempty"`
	// VisitorId: The visitor ID 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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SearchListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod SearchListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SearchResult: A search result contains information about a YouTube video,
// channel, or playlist that matches the search parameters specified in an API
// request. While a search result points to a uniquely identifiable resource,
// like a video, it does not have its own persistent data.
type SearchResult struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The id object contains information that can be used to uniquely identify
	// the resource that matches the search request.
	Id *ResourceId `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#searchResult".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about a search result,
	// such as its title or description. For example, if the search result is a
	// video, then the title will be the video's title and the description will be
	// the video's description.
	Snippet *SearchResultSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SearchResult) MarshalJSON() ([]byte, error) {
	type NoMethod SearchResult
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SearchResultSnippet: Basic details about a search result, including title,
// description and thumbnails of the item referenced by the search result.
type SearchResultSnippet struct {
	// ChannelId: The value that YouTube uses to uniquely identify the channel that
	// published the resource that the search result identifies.
	ChannelId string `json:"channelId,omitempty"`
	// ChannelTitle: The title of the channel that published the resource that the
	// search result identifies.
	ChannelTitle string `json:"channelTitle,omitempty"`
	// Description: A description of the search result.
	Description string `json:"description,omitempty"`
	// LiveBroadcastContent: It indicates if the resource (video or channel) has
	// upcoming/active live broadcast content. Or it's "none" if there is not any
	// upcoming/active live broadcasts.
	//
	// Possible values:
	//   "none" - The resource does not have live broadcast content.
	//   "upcoming" - The live broadcast is upcoming.
	//   "live" - The live broadcast is active.
	//   "completed" - The live broadcast has been completed.
	LiveBroadcastContent string `json:"liveBroadcastContent,omitempty"`
	// PublishedAt: The creation date and time of the resource that the search
	// result identifies.
	PublishedAt string `json:"publishedAt,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the search result. 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 search result.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SearchResultSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod SearchResultSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Subscription: A *subscription* resource contains information about a YouTube
// user subscription. A subscription notifies a user when new videos are added
// to a channel or when another user takes one of several actions on YouTube,
// such as uploading a video, rating a video, or commenting on a video.
type Subscription struct {
	// ContentDetails: The contentDetails object contains basic statistics about
	// the subscription.
	ContentDetails *SubscriptionContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the subscription.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#subscription".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the subscription,
	// including its title and the channel that the user subscribed to.
	Snippet *SubscriptionSnippet `json:"snippet,omitempty"`
	// SubscriberSnippet: The subscriberSnippet object contains basic details about
	// the subscriber.
	SubscriberSnippet *SubscriptionSubscriberSnippet `json:"subscriberSnippet,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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Subscription) MarshalJSON() ([]byte, error) {
	type NoMethod Subscription
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SubscriptionContentDetails: Details about the content to witch a
// subscription refers.
type SubscriptionContentDetails struct {
	// ActivityType: The type of activity this subscription is for (only uploads,
	// everything).
	//
	// Possible values:
	//   "subscriptionActivityTypeUnspecified"
	//   "all"
	//   "uploads"
	ActivityType string `json:"activityType,omitempty"`
	// NewItemCount: The number of new items in the subscription since its content
	// was last read.
	NewItemCount int64 `json:"newItemCount,omitempty"`
	// TotalItemCount: The approximate number of items that the subscription points
	// to.
	TotalItemCount int64 `json:"totalItemCount,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActivityType") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActivityType") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SubscriptionContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod SubscriptionContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type SubscriptionListResponse 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 subscriptions that match the request criteria.
	Items []*Subscription `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#subscriptionListResponse".
	Kind string `json:"kind,omitempty"`
	// NextPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the next page in the result set.
	NextPageToken string    `json:"nextPageToken,omitempty"`
	PageInfo      *PageInfo `json:"pageInfo,omitempty"`
	// PrevPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the previous page in the result set.
	PrevPageToken   string           `json:"prevPageToken,omitempty"`
	TokenPagination *TokenPagination `json:"tokenPagination,omitempty"`
	// VisitorId: The visitorId identifies the visitor.
	VisitorId string `json:"visitorId,omitempty"`

	// ServerResponse contains the HTTP response code and headers from the server.
	googleapi.ServerResponse `json:"-"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SubscriptionListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod SubscriptionListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SubscriptionSnippet: Basic details about a subscription, including title,
// description and thumbnails of the subscribed item.
type SubscriptionSnippet struct {
	// ChannelId: The ID that YouTube uses to uniquely identify the subscriber's
	// channel.
	ChannelId string `json:"channelId,omitempty"`
	// Description: The subscription's details.
	Description string `json:"description,omitempty"`
	// PublishedAt: The date and time that the subscription was created.
	PublishedAt string `json:"publishedAt,omitempty"`
	// ResourceId: The id object contains information about the channel that the
	// user subscribed to.
	ResourceId *ResourceId `json:"resourceId,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the video. 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 subscription's title.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SubscriptionSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod SubscriptionSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SubscriptionSubscriberSnippet: Basic details about a subscription's
// subscriber including title, description, channel ID and thumbnails.
type SubscriptionSubscriberSnippet struct {
	// ChannelId: The channel ID of the subscriber.
	ChannelId string `json:"channelId,omitempty"`
	// Description: The description of the subscriber.
	Description string `json:"description,omitempty"`
	// Thumbnails: Thumbnails for this subscriber.
	Thumbnails *ThumbnailDetails `json:"thumbnails,omitempty"`
	// Title: The title of the subscriber.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ChannelId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SubscriptionSubscriberSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod SubscriptionSubscriberSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// SuperChatEvent: A `__superChatEvent__` resource represents a Super Chat
// purchase on a YouTube channel.
type SuperChatEvent struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube assigns to uniquely identify the Super Chat event.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#superChatEvent".
	Kind string `json:"kind,omitempty"`
	// Snippet: The `snippet` object contains basic details about the Super Chat
	// event.
	Snippet *SuperChatEventSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SuperChatEvent) MarshalJSON() ([]byte, error) {
	type NoMethod SuperChatEvent
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type SuperChatEventListResponse 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 Super Chat purchases that match the request criteria.
	Items []*SuperChatEvent `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#superChatEventListResponse".
	Kind string `json:"kind,omitempty"`
	// NextPageToken: The token that can be used as the value of the pageToken
	// parameter to retrieve the next page in the result set.
	NextPageToken   string           `json:"nextPageToken,omitempty"`
	PageInfo        *PageInfo        `json:"pageInfo,omitempty"`
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SuperChatEventListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod SuperChatEventListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type SuperChatEventSnippet struct {
	// AmountMicros: The purchase amount, in micros of the purchase currency. e.g.,
	// 1 is represented as 1000000.
	AmountMicros uint64 `json:"amountMicros,omitempty,string"`
	// ChannelId: Channel id where the event occurred.
	ChannelId string `json:"channelId,omitempty"`
	// CommentText: The text contents of the comment left by the user.
	CommentText string `json:"commentText,omitempty"`
	// CreatedAt: The date and time when the event occurred.
	CreatedAt string `json:"createdAt,omitempty"`
	// Currency: The currency in which the purchase was made. ISO 4217.
	Currency string `json:"currency,omitempty"`
	// DisplayString: A rendered string that displays the purchase amount and
	// currency (e.g., "$1.00"). The string is rendered for the given language.
	DisplayString string `json:"displayString,omitempty"`
	// IsSuperStickerEvent: True if this event is a Super Sticker event.
	IsSuperStickerEvent bool `json:"isSuperStickerEvent,omitempty"`
	// MessageType: The tier for the paid message, which is based on the amount of
	// money spent to purchase the message.
	MessageType int64 `json:"messageType,omitempty"`
	// SuperStickerMetadata: If this event is a Super Sticker event, this field
	// will contain metadata about the Super Sticker.
	SuperStickerMetadata *SuperStickerMetadata `json:"superStickerMetadata,omitempty"`
	// SupporterDetails: Details about the supporter.
	SupporterDetails *ChannelProfileDetails `json:"supporterDetails,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AmountMicros") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AmountMicros") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SuperChatEventSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod SuperChatEventSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type SuperStickerMetadata struct {
	// AltText: Internationalized alt text that describes the sticker image and any
	// animation associated with it.
	AltText string `json:"altText,omitempty"`
	// AltTextLanguage: Specifies the localization language in which the alt text
	// is returned.
	AltTextLanguage string `json:"altTextLanguage,omitempty"`
	// StickerId: Unique identifier of the Super Sticker. This is a shorter form of
	// the alt_text that includes pack name and a recognizable characteristic of
	// the sticker.
	StickerId string `json:"stickerId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AltText") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AltText") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s SuperStickerMetadata) MarshalJSON() ([]byte, error) {
	type NoMethod SuperStickerMetadata
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type TestItem struct {
	// Etag: Etag for the resource. See https://en.wikipedia.org/wiki/HTTP_ETag.
	Etag         string                   `json:"etag,omitempty"`
	FeaturedPart bool                     `json:"featuredPart,omitempty"`
	Gaia         int64                    `json:"gaia,omitempty,string"`
	Id           string                   `json:"id,omitempty"`
	Snippet      *TestItemTestItemSnippet `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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s TestItem) MarshalJSON() ([]byte, error) {
	type NoMethod TestItem
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type TestItemTestItemSnippet struct {
}

// ThirdPartyLink: A *third party account link* resource represents a link
// between a YouTube account or a channel and an account on a third-party
// service.
type ThirdPartyLink struct {
	// Etag: Etag of this resource
	Etag string `json:"etag,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#thirdPartyLink".
	Kind string `json:"kind,omitempty"`
	// LinkingToken: The linking_token identifies a YouTube account and channel
	// with which the third party account is linked.
	LinkingToken string `json:"linkingToken,omitempty"`
	// Snippet: The snippet object contains basic details about the third- party
	// account link.
	Snippet *ThirdPartyLinkSnippet `json:"snippet,omitempty"`
	// Status: The status object contains information about the status of the link.
	Status *ThirdPartyLinkStatus `json:"status,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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThirdPartyLink) MarshalJSON() ([]byte, error) {
	type NoMethod ThirdPartyLink
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type ThirdPartyLinkListResponse struct {
	// Etag: Etag of this resource.
	Etag  string            `json:"etag,omitempty"`
	Items []*ThirdPartyLink `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#thirdPartyLinkListResponse".
	Kind string `json:"kind,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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThirdPartyLinkListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ThirdPartyLinkListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ThirdPartyLinkSnippet: Basic information about a third party account link,
// including its type and type-specific information.
type ThirdPartyLinkSnippet struct {
	// ChannelToAffiliateProgramLink: Information specific to a link between a
	// channel and an affiliate program of a partner.
	ChannelToAffiliateProgramLink *ChannelToAffiliateProgramLinkDetails `json:"channelToAffiliateProgramLink,omitempty"`
	// ChannelToStoreLink: Information specific to a link between a channel and a
	// store on a merchandising platform.
	ChannelToStoreLink *ChannelToStoreLinkDetails `json:"channelToStoreLink,omitempty"`
	// Type: Type of the link named after the entities that are being linked.
	//
	// Possible values:
	//   "linkUnspecified"
	//   "channelToStoreLink" - A link that is connecting (or about to connect) a
	// channel with a store on a merchandising platform in order to enable retail
	// commerce capabilities for that channel on YouTube.
	//   "channelToAffiliateProgramLink" - A link that is connecting (or about to
	// connect) a channel with an affiliate program of a partner to enable that
	// channel to earn commissions from that partner through affiliate links.
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "ChannelToAffiliateProgramLink") to unconditionally include in API requests.
	// By default, fields with empty or default values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields
	// for more details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ChannelToAffiliateProgramLink")
	// to include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThirdPartyLinkSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod ThirdPartyLinkSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ThirdPartyLinkStatus: The third-party link status object contains
// information about the status of the link.
type ThirdPartyLinkStatus struct {
	// Possible values:
	//   "unknown"
	//   "failed"
	//   "pending"
	//   "linked"
	LinkStatus string `json:"linkStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "LinkStatus") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "LinkStatus") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThirdPartyLinkStatus) MarshalJSON() ([]byte, error) {
	type NoMethod ThirdPartyLinkStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// Thumbnail: A thumbnail is an image representing a YouTube resource.
type Thumbnail struct {
	// Height: (Optional) Height of the thumbnail image.
	Height int64 `json:"height,omitempty"`
	// Url: The thumbnail image's URL.
	Url string `json:"url,omitempty"`
	// Width: (Optional) Width of the thumbnail image.
	Width int64 `json:"width,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Height") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Height") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Thumbnail) MarshalJSON() ([]byte, error) {
	type NoMethod Thumbnail
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// ThumbnailDetails: Internal representation of thumbnails for a YouTube
// resource.
type ThumbnailDetails struct {
	// Default: The default image for this resource.
	Default *Thumbnail `json:"default,omitempty"`
	// Fhd: The full high definition (1080p) quality image for this resource.
	Fhd *Thumbnail `json:"fhd,omitempty"`
	// High: The high quality image for this resource.
	High *Thumbnail `json:"high,omitempty"`
	// Maxres: The maximum resolution quality image for this resource.
	Maxres *Thumbnail `json:"maxres,omitempty"`
	// Medium: The medium quality image for this resource.
	Medium *Thumbnail `json:"medium,omitempty"`
	// Qhd: The quad high definition (1440p / 2K) quality image for this resource.
	Qhd *Thumbnail `json:"qhd,omitempty"`
	// Standard: The standard quality image for this resource.
	Standard *Thumbnail `json:"standard,omitempty"`
	// Uhd: The ultra-high resolution (4K) quality image for this resource.
	Uhd *Thumbnail `json:"uhd,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Default") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Default") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThumbnailDetails) MarshalJSON() ([]byte, error) {
	type NoMethod ThumbnailDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type ThumbnailSetResponse 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 thumbnails.
	Items []*ThumbnailDetails `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#thumbnailSetResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s ThumbnailSetResponse) MarshalJSON() ([]byte, error) {
	type NoMethod ThumbnailSetResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// TokenPagination: Stub token pagination template to suppress results.
type TokenPagination struct {
}

// Video: A *video* resource represents a YouTube video.
type Video struct {
	// AgeGating: Age restriction details related to a video. This data can only be
	// retrieved by the video owner.
	AgeGating    *VideoAgeGating `json:"ageGating,omitempty"`
	BrandPartner *BrandPartner   `json:"brandPartner,omitempty"`
	// ContentDetails: The contentDetails object contains information about the
	// video content, including the length of the video and its aspect ratio.
	ContentDetails *VideoContentDetails `json:"contentDetails,omitempty"`
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// FileDetails: The fileDetails object encapsulates information about the video
	// file that was uploaded to YouTube, including the file's resolution,
	// duration, audio and video codecs, stream bitrates, and more. This data can
	// only be retrieved by the video owner.
	FileDetails *VideoFileDetails `json:"fileDetails,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the video.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#video".
	Kind string `json:"kind,omitempty"`
	// LiveStreamingDetails: The liveStreamingDetails object contains metadata
	// about a live video broadcast. The object will only be present in a video
	// resource if the video is an upcoming, live, or completed live broadcast.
	LiveStreamingDetails *VideoLiveStreamingDetails `json:"liveStreamingDetails,omitempty"`
	// Localizations: The localizations object contains localized versions of the
	// basic details about the video, such as its title and description.
	Localizations map[string]VideoLocalization `json:"localizations,omitempty"`
	// MonetizationDetails: The monetizationDetails object encapsulates information
	// about the monetization status of the video.
	MonetizationDetails         *VideoMonetizationDetails         `json:"monetizationDetails,omitempty"`
	PaidProductPlacementDetails *VideoPaidProductPlacementDetails `json:"paidProductPlacementDetails,omitempty"`
	// Player: The player object contains information that you would use to play
	// the video in an embedded player.
	Player *VideoPlayer `json:"player,omitempty"`
	// ProcessingDetails: The processingDetails object encapsulates information
	// about YouTube's progress in processing the uploaded video file. The
	// properties in the object identify the current processing status and an
	// estimate of the time remaining until YouTube finishes processing the video.
	// This part also indicates whether different types of data or content, such as
	// file details or thumbnail images, are available for the video. The
	// processingProgress object is designed to be polled so that the video
	// uploaded can track the progress that YouTube has made in processing the
	// uploaded video file. This data can only be retrieved by the video owner.
	ProcessingDetails *VideoProcessingDetails `json:"processingDetails,omitempty"`
	// ProjectDetails: The projectDetails object contains information about the
	// project specific video metadata. b/157517979: This part was never populated
	// after it was added. However, it sees non-zero traffic because there is
	// generated client code in the wild that refers to it [1]. We keep this field
	// and do NOT remove it because otherwise V3 would return an error when this
	// part gets requested [2]. [1]
	// https://developers.google.com/resources/api-libraries/documentation/youtube/v3/csharp/latest/classGoogle_1_1Apis_1_1YouTube_1_1v3_1_1Data_1_1VideoProjectDetails.html
	// [2]
	// http://google3/video/youtube/src/python/servers/data_api/common.py?l=1565-1569&rcl=344141677
	ProjectDetails *VideoProjectDetails `json:"projectDetails,omitempty"`
	// RecordingDetails: The recordingDetails object encapsulates information about
	// the location, date and address where the video was recorded.
	RecordingDetails *VideoRecordingDetails `json:"recordingDetails,omitempty"`
	// Snippet: The snippet object contains basic details about the video, such as
	// its title, description, and category.
	Snippet *VideoSnippet `json:"snippet,omitempty"`
	// Statistics: The statistics object contains statistics about the video.
	Statistics *VideoStatistics `json:"statistics,omitempty"`
	// Status: The status object contains information about the video's uploading,
	// processing, and privacy statuses.
	Status *VideoStatus `json:"status,omitempty"`
	// Suggestions: The suggestions object encapsulates suggestions that identify
	// opportunities to improve the video quality or the metadata for the uploaded
	// video. This data can only be retrieved by the video owner.
	Suggestions *VideoSuggestions `json:"suggestions,omitempty"`
	// TopicDetails: The topicDetails object encapsulates information about
	// Freebase (http://www.freebase.com) topics associated with the video.
	TopicDetails *VideoTopicDetails `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. "AgeGating") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AgeGating") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s Video) MarshalJSON() ([]byte, error) {
	type NoMethod Video
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoAbuseReport struct {
	// Comments: Additional comments regarding the abuse report.
	Comments string `json:"comments,omitempty"`
	// Language: The language that the content was viewed in.
	Language string `json:"language,omitempty"`
	// ReasonId: The high-level, or primary, reason that the content is abusive.
	// The value is an abuse report reason ID.
	ReasonId string `json:"reasonId,omitempty"`
	// SecondaryReasonId: The specific, or secondary, reason that this content is
	// abusive (if available). The value is an abuse report reason ID that is a
	// valid secondary reason for the primary reason.
	SecondaryReasonId string `json:"secondaryReasonId,omitempty"`
	// VideoId: The ID that YouTube uses to uniquely identify the video.
	VideoId string `json:"videoId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Comments") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Comments") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAbuseReport) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAbuseReport
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoAbuseReportReason: A `__videoAbuseReportReason__` resource identifies a
// reason that a video could be reported as abusive. Video abuse report reasons
// are used with `video.ReportAbuse`.
type VideoAbuseReportReason struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID of this abuse report reason.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoAbuseReportReason".
	Kind string `json:"kind,omitempty"`
	// Snippet: The `snippet` object contains basic details about the abuse report
	// reason.
	Snippet *VideoAbuseReportReasonSnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAbuseReportReason) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAbuseReportReason
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoAbuseReportReasonListResponse 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 valid abuse reasons that are used with `video.ReportAbuse`.
	Items []*VideoAbuseReportReason `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoAbuseReportReasonListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAbuseReportReasonListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAbuseReportReasonListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoAbuseReportReasonSnippet: Basic details about a video category, such as
// its localized title.
type VideoAbuseReportReasonSnippet struct {
	// Label: The localized label belonging to this abuse report reason.
	Label string `json:"label,omitempty"`
	// SecondaryReasons: The secondary reasons associated with this reason, if any
	// are available. (There might be 0 or more.)
	SecondaryReasons []*VideoAbuseReportSecondaryReason `json:"secondaryReasons,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Label") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Label") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAbuseReportReasonSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAbuseReportReasonSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoAbuseReportSecondaryReason struct {
	// Id: The ID of this abuse report secondary reason.
	Id string `json:"id,omitempty"`
	// Label: The localized label for this abuse report secondary reason.
	Label string `json:"label,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Id") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAbuseReportSecondaryReason) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAbuseReportSecondaryReason
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoAgeGating struct {
	// AlcoholContent: Indicates whether or not the video has alcoholic beverage
	// content. Only users of legal purchasing age in a particular country, as
	// identified by ICAP, can view the content.
	AlcoholContent bool `json:"alcoholContent,omitempty"`
	// Restricted: Age-restricted trailers. For redband trailers and adult-rated
	// video-games. Only users aged 18+ can view the content. The the field is true
	// the content is restricted to viewers aged 18+. Otherwise The field won't be
	// present.
	Restricted bool `json:"restricted,omitempty"`
	// VideoGameRating: Video game rating, if any.
	//
	// Possible values:
	//   "anyone"
	//   "m15Plus"
	//   "m16Plus"
	//   "m17Plus"
	VideoGameRating string `json:"videoGameRating,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AlcoholContent") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AlcoholContent") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoAgeGating) MarshalJSON() ([]byte, error) {
	type NoMethod VideoAgeGating
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoCategory: A *videoCategory* resource identifies a category that has
// been or could be associated with uploaded videos.
type VideoCategory struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: The ID that YouTube uses to uniquely identify the video category.
	Id string `json:"id,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoCategory".
	Kind string `json:"kind,omitempty"`
	// Snippet: The snippet object contains basic details about the video category,
	// including its title.
	Snippet *VideoCategorySnippet `json:"snippet,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Etag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoCategory) MarshalJSON() ([]byte, error) {
	type NoMethod VideoCategory
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoCategoryListResponse 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 video categories that can be associated with YouTube
	// videos. In this map, the video category ID is the map key, and its value is
	// the corresponding videoCategory resource.
	Items []*VideoCategory `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoCategoryListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoCategoryListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod VideoCategoryListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoCategorySnippet: Basic details about a video category, such as its
// localized title.
type VideoCategorySnippet struct {
	Assignable bool `json:"assignable,omitempty"`
	// ChannelId: The YouTube channel that created the video category.
	ChannelId string `json:"channelId,omitempty"`
	// Title: The video category's title.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Assignable") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Assignable") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoCategorySnippet) MarshalJSON() ([]byte, error) {
	type NoMethod VideoCategorySnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoContentDetails: Details about the content of a YouTube Video.
type VideoContentDetails struct {
	// Caption: The value of captions indicates whether the video has captions or
	// not.
	//
	// Possible values:
	//   "true"
	//   "false"
	Caption string `json:"caption,omitempty"`
	// ContentRating: Specifies the ratings that the video received under various
	// rating schemes.
	ContentRating *ContentRating `json:"contentRating,omitempty"`
	// CountryRestriction: The countryRestriction object contains information about
	// the countries where a video is (or is not) viewable.
	CountryRestriction *AccessPolicy `json:"countryRestriction,omitempty"`
	// Definition: The value of definition indicates whether the video is available
	// in high definition or only in standard definition.
	//
	// Possible values:
	//   "sd" - sd
	//   "hd" - hd
	Definition string `json:"definition,omitempty"`
	// Dimension: The value of dimension indicates whether the video is available
	// in 3D or in 2D.
	Dimension string `json:"dimension,omitempty"`
	// Duration: The length of the video. The tag value is an ISO 8601 duration in
	// the format PT#M#S, in which the letters PT indicate that the value specifies
	// a period of time, and the letters M and S refer to length in minutes and
	// seconds, respectively. The # characters preceding the M and S letters are
	// both integers that specify the number of minutes (or seconds) of the video.
	// For example, a value of PT15M51S indicates that the video is 15 minutes and
	// 51 seconds long.
	Duration string `json:"duration,omitempty"`
	// HasCustomThumbnail: Indicates whether the video uploader has provided a
	// custom thumbnail image for the video. This property is only visible to the
	// video uploader.
	HasCustomThumbnail bool `json:"hasCustomThumbnail,omitempty"`
	// LicensedContent: The value of is_license_content indicates whether the video
	// is licensed content.
	LicensedContent bool `json:"licensedContent,omitempty"`
	// Projection: Specifies the projection format of the video.
	//
	// Possible values:
	//   "rectangular"
	//   "360"
	Projection string `json:"projection,omitempty"`
	// RegionRestriction: The regionRestriction object contains information about
	// the countries where a video is (or is not) viewable. The object will contain
	// either the contentDetails.regionRestriction.allowed property or the
	// contentDetails.regionRestriction.blocked property.
	RegionRestriction *VideoContentDetailsRegionRestriction `json:"regionRestriction,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Caption") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Caption") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoContentDetailsRegionRestriction: DEPRECATED Region restriction of the
// video.
type VideoContentDetailsRegionRestriction struct {
	// Allowed: A list of region codes that identify countries where the video is
	// viewable. If this property is present and a country is not listed in its
	// value, then the video is blocked from appearing in that country. If this
	// property is present and contains an empty list, the video is blocked in all
	// countries.
	Allowed []string `json:"allowed,omitempty"`
	// Blocked: A list of region codes that identify countries where the video is
	// blocked. If this property is present and a country is not listed in its
	// value, then the video is viewable in that country. If this property is
	// present and contains an empty list, the video is viewable in all countries.
	Blocked []string `json:"blocked,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Allowed") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoContentDetailsRegionRestriction) MarshalJSON() ([]byte, error) {
	type NoMethod VideoContentDetailsRegionRestriction
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoFileDetails: Describes original video file properties, including
// technical details about audio and video streams, but also metadata
// information like content length, digitization time, or geotagging
// information.
type VideoFileDetails struct {
	// AudioStreams: A list of audio streams contained in the uploaded video file.
	// Each item in the list contains detailed metadata about an audio stream.
	AudioStreams []*VideoFileDetailsAudioStream `json:"audioStreams,omitempty"`
	// BitrateBps: The uploaded video file's combined (video and audio) bitrate in
	// bits per second.
	BitrateBps uint64 `json:"bitrateBps,omitempty,string"`
	// Container: The uploaded video file's container format.
	Container string `json:"container,omitempty"`
	// CreationTime: The date and time when the uploaded video file was created.
	// The value is specified in ISO 8601 format. Currently, the following ISO 8601
	// formats are supported: - Date only: YYYY-MM-DD - Naive time:
	// YYYY-MM-DDTHH:MM:SS - Time with timezone: YYYY-MM-DDTHH:MM:SS+HH:MM
	CreationTime string `json:"creationTime,omitempty"`
	// DurationMs: The length of the uploaded video in milliseconds.
	DurationMs uint64 `json:"durationMs,omitempty,string"`
	// FileName: The uploaded file's name. This field is present whether a video
	// file or another type of file was uploaded.
	FileName string `json:"fileName,omitempty"`
	// FileSize: The uploaded file's size in bytes. This field is present whether a
	// video file or another type of file was uploaded.
	FileSize uint64 `json:"fileSize,omitempty,string"`
	// FileType: The uploaded file's type as detected by YouTube's video processing
	// engine. Currently, YouTube only processes video files, but this field is
	// present whether a video file or another type of file was uploaded.
	//
	// Possible values:
	//   "video" - Known video file (e.g., an MP4 file).
	//   "audio" - Audio only file (e.g., an MP3 file).
	//   "image" - Image file (e.g., a JPEG image).
	//   "archive" - Archive file (e.g., a ZIP archive).
	//   "document" - Document or text file (e.g., MS Word document).
	//   "project" - Movie project file (e.g., Microsoft Windows Movie Maker
	// project).
	//   "other" - Other non-video file type.
	FileType string `json:"fileType,omitempty"`
	// VideoStreams: A list of video streams contained in the uploaded video file.
	// Each item in the list contains detailed metadata about a video stream.
	VideoStreams []*VideoFileDetailsVideoStream `json:"videoStreams,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AudioStreams") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AudioStreams") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoFileDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoFileDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoFileDetailsAudioStream: Information about an audio stream.
type VideoFileDetailsAudioStream struct {
	// BitrateBps: The audio stream's bitrate, in bits per second.
	BitrateBps uint64 `json:"bitrateBps,omitempty,string"`
	// ChannelCount: The number of audio channels that the stream contains.
	ChannelCount int64 `json:"channelCount,omitempty"`
	// Codec: The audio codec that the stream uses.
	Codec string `json:"codec,omitempty"`
	// Vendor: A value that uniquely identifies a video vendor. Typically, the
	// value is a four-letter vendor code.
	Vendor string `json:"vendor,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BitrateBps") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BitrateBps") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoFileDetailsAudioStream) MarshalJSON() ([]byte, error) {
	type NoMethod VideoFileDetailsAudioStream
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoFileDetailsVideoStream: Information about a video stream.
type VideoFileDetailsVideoStream struct {
	// AspectRatio: The video content's display aspect ratio, which specifies the
	// aspect ratio in which the video should be displayed.
	AspectRatio float64 `json:"aspectRatio,omitempty"`
	// BitrateBps: The video stream's bitrate, in bits per second.
	BitrateBps uint64 `json:"bitrateBps,omitempty,string"`
	// Codec: The video codec that the stream uses.
	Codec string `json:"codec,omitempty"`
	// FrameRateFps: The video stream's frame rate, in frames per second.
	FrameRateFps float64 `json:"frameRateFps,omitempty"`
	// HeightPixels: The encoded video content's height in pixels.
	HeightPixels int64 `json:"heightPixels,omitempty"`
	// Rotation: The amount that YouTube needs to rotate the original source
	// content to properly display the video.
	//
	// Possible values:
	//   "none"
	//   "clockwise"
	//   "upsideDown"
	//   "counterClockwise"
	//   "other"
	Rotation string `json:"rotation,omitempty"`
	// Vendor: A value that uniquely identifies a video vendor. Typically, the
	// value is a four-letter vendor code.
	Vendor string `json:"vendor,omitempty"`
	// WidthPixels: The encoded video content's width in pixels. You can calculate
	// the video's encoding aspect ratio as width_pixels / height_pixels.
	WidthPixels int64 `json:"widthPixels,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AspectRatio") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AspectRatio") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoFileDetailsVideoStream) MarshalJSON() ([]byte, error) {
	type NoMethod VideoFileDetailsVideoStream
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

func (s *VideoFileDetailsVideoStream) UnmarshalJSON(data []byte) error {
	type NoMethod VideoFileDetailsVideoStream
	var s1 struct {
		AspectRatio  gensupport.JSONFloat64 `json:"aspectRatio"`
		FrameRateFps gensupport.JSONFloat64 `json:"frameRateFps"`
		*NoMethod
	}
	s1.NoMethod = (*NoMethod)(s)
	if err := json.Unmarshal(data, &s1); err != nil {
		return err
	}
	s.AspectRatio = float64(s1.AspectRatio)
	s.FrameRateFps = float64(s1.FrameRateFps)
	return nil
}

type VideoGetRatingResponse 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 ratings that match the request criteria.
	Items []*VideoRating `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoGetRatingResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoGetRatingResponse) MarshalJSON() ([]byte, error) {
	type NoMethod VideoGetRatingResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type VideoListResponse 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   []*Video `json:"items,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoListResponse".
	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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoListResponse) MarshalJSON() ([]byte, error) {
	type NoMethod VideoListResponse
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoLiveStreamingDetails: Details about the live streaming metadata.
type VideoLiveStreamingDetails struct {
	// ActiveLiveChatId: The ID of the currently active live chat attached to this
	// video. This field is filled only if the video is a currently live broadcast
	// that has live chat. Once the broadcast transitions to complete this field
	// will be removed and the live chat closed down. For persistent broadcasts
	// that live chat id will no longer be tied to this video but rather to the new
	// video being displayed at the persistent page.
	ActiveLiveChatId string `json:"activeLiveChatId,omitempty"`
	// ActualEndTime: The time that the broadcast actually ended. This value will
	// not be available until the broadcast is over.
	ActualEndTime string `json:"actualEndTime,omitempty"`
	// ActualStartTime: The time that the broadcast actually started. This value
	// will not be available until the broadcast begins.
	ActualStartTime string `json:"actualStartTime,omitempty"`
	// ConcurrentViewers: The number of viewers currently watching the broadcast.
	// The property and its value will be present if the broadcast has current
	// viewers and the broadcast owner has not hidden the viewcount for the video.
	// Note that YouTube stops tracking the number of concurrent viewers for a
	// broadcast when the broadcast ends. So, this property would not identify the
	// number of viewers watching an archived video of a live broadcast that
	// already ended.
	ConcurrentViewers uint64 `json:"concurrentViewers,omitempty,string"`
	// ScheduledEndTime: The time that the broadcast is scheduled to end. If the
	// value is empty or the property is not present, then the broadcast is
	// scheduled to continue indefinitely.
	ScheduledEndTime string `json:"scheduledEndTime,omitempty"`
	// ScheduledStartTime: The time that the broadcast is scheduled to begin.
	ScheduledStartTime string `json:"scheduledStartTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ActiveLiveChatId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ActiveLiveChatId") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoLiveStreamingDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoLiveStreamingDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoLocalization: Localized versions of certain video properties (e.g.
// title).
type VideoLocalization struct {
	// Description: Localized version of the video's description.
	Description string `json:"description,omitempty"`
	// Title: Localized version of the video'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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoLocalization) MarshalJSON() ([]byte, error) {
	type NoMethod VideoLocalization
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoMonetizationDetails: Details about monetization of a YouTube Video.
type VideoMonetizationDetails struct {
	// Access: The value of access indicates whether the video can be monetized or
	// not.
	Access *AccessPolicy `json:"access,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Access") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Access") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoMonetizationDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoMonetizationDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoPaidProductPlacementDetails: Details about paid content, such as paid
// product placement, sponsorships or endorsement, contained in a YouTube video
// and a method to inform viewers of paid promotion. This data can only be
// retrieved by the video owner.
type VideoPaidProductPlacementDetails struct {
	// HasPaidProductPlacement: This boolean represents whether the video contains
	// Paid Product Placement, Studio equivalent:
	// https://screenshot.googleplex.com/4Me79DE6AfT2ktp.png
	HasPaidProductPlacement bool `json:"hasPaidProductPlacement,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HasPaidProductPlacement") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HasPaidProductPlacement") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoPaidProductPlacementDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoPaidProductPlacementDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoPlayer: Player to be used for a video playback.
type VideoPlayer struct {
	EmbedHeight int64 `json:"embedHeight,omitempty,string"`
	// EmbedHtml: An <iframe> tag that embeds a player that will play the video.
	EmbedHtml string `json:"embedHtml,omitempty"`
	// EmbedWidth: The embed width
	EmbedWidth int64 `json:"embedWidth,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "EmbedHeight") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EmbedHeight") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoPlayer) MarshalJSON() ([]byte, error) {
	type NoMethod VideoPlayer
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoProcessingDetails: Describes processing status and progress and
// availability of some other Video resource parts.
type VideoProcessingDetails struct {
	// EditorSuggestionsAvailability: This value indicates whether video editing
	// suggestions, which might improve video quality or the playback experience,
	// are available for the video. You can retrieve these suggestions by
	// requesting the suggestions part in your videos.list() request.
	EditorSuggestionsAvailability string `json:"editorSuggestionsAvailability,omitempty"`
	// FileDetailsAvailability: This value indicates whether file details are
	// available for the uploaded video. You can retrieve a video's file details by
	// requesting the fileDetails part in your videos.list() request.
	FileDetailsAvailability string `json:"fileDetailsAvailability,omitempty"`
	// ProcessingFailureReason: The reason that YouTube failed to process the
	// video. This property will only have a value if the processingStatus
	// property's value is failed.
	//
	// Possible values:
	//   "uploadFailed"
	//   "transcodeFailed"
	//   "streamingFailed"
	//   "other"
	ProcessingFailureReason string `json:"processingFailureReason,omitempty"`
	// ProcessingIssuesAvailability: This value indicates whether the video
	// processing engine has generated suggestions that might improve YouTube's
	// ability to process the the video, warnings that explain video processing
	// problems, or errors that cause video processing problems. You can retrieve
	// these suggestions by requesting the suggestions part in your videos.list()
	// request.
	ProcessingIssuesAvailability string `json:"processingIssuesAvailability,omitempty"`
	// ProcessingProgress: The processingProgress object contains information about
	// the progress YouTube has made in processing the video. The values are really
	// only relevant if the video's processing status is processing.
	ProcessingProgress *VideoProcessingDetailsProcessingProgress `json:"processingProgress,omitempty"`
	// ProcessingStatus: The video's processing status. This value indicates
	// whether YouTube was able to process the video or if the video is still being
	// processed.
	//
	// Possible values:
	//   "processing"
	//   "succeeded"
	//   "failed"
	//   "terminated"
	ProcessingStatus string `json:"processingStatus,omitempty"`
	// TagSuggestionsAvailability: This value indicates whether keyword (tag)
	// suggestions are available for the video. Tags can be added to a video's
	// metadata to make it easier for other users to find the video. You can
	// retrieve these suggestions by requesting the suggestions part in your
	// videos.list() request.
	TagSuggestionsAvailability string `json:"tagSuggestionsAvailability,omitempty"`
	// ThumbnailsAvailability: This value indicates whether thumbnail images have
	// been generated for the video.
	ThumbnailsAvailability string `json:"thumbnailsAvailability,omitempty"`
	// ForceSendFields is a list of field names (e.g.
	// "EditorSuggestionsAvailability") to unconditionally include in API requests.
	// By default, fields with empty or default values are omitted from API
	// requests. See https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields
	// for more details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EditorSuggestionsAvailability")
	// to include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoProcessingDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoProcessingDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoProcessingDetailsProcessingProgress: Video processing progress and
// completion time estimate.
type VideoProcessingDetailsProcessingProgress struct {
	// PartsProcessed: The number of parts of the video that YouTube has already
	// processed. You can estimate the percentage of the video that YouTube has
	// already processed by calculating: 100 * parts_processed / parts_total Note
	// that since the estimated number of parts could increase without a
	// corresponding increase in the number of parts that have already been
	// processed, it is possible that the calculated progress could periodically
	// decrease while YouTube processes a video.
	PartsProcessed uint64 `json:"partsProcessed,omitempty,string"`
	// PartsTotal: An estimate of the total number of parts that need to be
	// processed for the video. The number may be updated with more precise
	// estimates while YouTube processes the video.
	PartsTotal uint64 `json:"partsTotal,omitempty,string"`
	// TimeLeftMs: An estimate of the amount of time, in millseconds, that YouTube
	// needs to finish processing the video.
	TimeLeftMs uint64 `json:"timeLeftMs,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "PartsProcessed") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "PartsProcessed") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoProcessingDetailsProcessingProgress) MarshalJSON() ([]byte, error) {
	type NoMethod VideoProcessingDetailsProcessingProgress
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoProjectDetails: DEPRECATED. b/157517979: This part was never populated
// after it was added. However, it sees non-zero traffic because there is
// generated client code in the wild that refers to it [1]. We keep this field
// and do NOT remove it because otherwise V3 would return an error when this
// part gets requested [2]. [1]
// https://developers.google.com/resources/api-libraries/documentation/youtube/v3/csharp/latest/classGoogle_1_1Apis_1_1YouTube_1_1v3_1_1Data_1_1VideoProjectDetails.html
// [2]
// http://google3/video/youtube/src/python/servers/data_api/common.py?l=1565-1569&rcl=344141677
type VideoProjectDetails struct {
}

// VideoRating: Basic details about rating of a video.
type VideoRating struct {
	// Rating: Rating of a video.
	//
	// Possible values:
	//   "none" - The entity has not been rated.
	//   "like" - The entity is liked.
	//   "dislike" - The entity is disliked.
	Rating string `json:"rating,omitempty"`
	// VideoId: The ID that YouTube uses to uniquely identify the video.
	VideoId string `json:"videoId,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Rating") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Rating") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoRating) MarshalJSON() ([]byte, error) {
	type NoMethod VideoRating
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoRecordingDetails: Recording information associated with the video.
type VideoRecordingDetails struct {
	// Location: The geolocation information associated with the video.
	Location *GeoPoint `json:"location,omitempty"`
	// LocationDescription: The text description of the location where the video
	// was recorded.
	LocationDescription string `json:"locationDescription,omitempty"`
	// RecordingDate: The date and time when the video was recorded.
	RecordingDate string `json:"recordingDate,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Location") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Location") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoRecordingDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoRecordingDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoSnippet: Basic details about a video, including title, description,
// uploader, thumbnails and category.
type VideoSnippet struct {
	// CategoryId: The YouTube video category
	// (https://developers.google.com/youtube/data/reference/rest/v3/videoCategories/list)
	// associated with the video.
	CategoryId string `json:"categoryId,omitempty"`
	// ChannelId: The ID that YouTube uses to uniquely identify the channel that
	// the video was uploaded to.
	ChannelId string `json:"channelId,omitempty"`
	// ChannelTitle: Channel title for the channel that the video belongs to.
	ChannelTitle string `json:"channelTitle,omitempty"`
	// DefaultAudioLanguage: The default_audio_language property specifies the
	// language spoken in the video's default audio track.
	DefaultAudioLanguage string `json:"defaultAudioLanguage,omitempty"`
	// DefaultLanguage: The language of the videos's default snippet.
	DefaultLanguage string `json:"defaultLanguage,omitempty"`
	// Description: The video's description. @mutable youtube.videos.insert
	// youtube.videos.update
	Description string `json:"description,omitempty"`
	// LiveBroadcastContent: Indicates if the video is an upcoming/active live
	// broadcast. Or it's "none" if the video is not an upcoming/active live
	// broadcast.
	//
	// Possible values:
	//   "none" - The resource does not have live broadcast content.
	//   "upcoming" - The live broadcast is upcoming.
	//   "live" - The live broadcast is active.
	//   "completed" - The live broadcast has been completed.
	LiveBroadcastContent string `json:"liveBroadcastContent,omitempty"`
	// Localized: Localized snippet selected with the hl parameter. If no such
	// localization exists, this field is populated with the default snippet.
	// (Read-only)
	Localized *VideoLocalization `json:"localized,omitempty"`
	// PublishedAt: The date and time when the video was uploaded.
	PublishedAt string `json:"publishedAt,omitempty"`
	// Tags: A list of keyword tags associated with the video. Tags may contain
	// spaces.
	Tags []string `json:"tags,omitempty"`
	// Thumbnails: A map of thumbnail images associated with the video. 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 video's title. @mutable youtube.videos.insert
	// youtube.videos.update
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CategoryId") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CategoryId") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod VideoSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStat: A *VideoStat* resource represents a YouTube video's stats.
type VideoStat struct {
	// ContentDetails: Output only. The VideoStatsContentDetails object contains
	// information about the video content, including the length of the video.
	ContentDetails *VideoStatsContentDetails `json:"contentDetails,omitempty"`
	// Etag: Output only. Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Id: Output only. The ID that YouTube uses to uniquely identify the video.
	Id string `json:"id,omitempty"`
	// Kind: Output only. Identifies what kind of resource this is. Value: the
	// fixed string "youtube#videoStats".
	Kind string `json:"kind,omitempty"`
	// Snippet: Output only. The VideoStatsSnippet object contains basic details
	// about the video, such publish time.
	Snippet *VideoStatsSnippet `json:"snippet,omitempty"`
	// Statistics: Output only. The VideoStatsStatistics object contains statistics
	// about the video.
	Statistics *VideoStatsStatistics `json:"statistics,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ContentDetails") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStat) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStat
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStatistics: Statistics about the video, such as the number of times the
// video was viewed or liked.
type VideoStatistics struct {
	// CommentCount: The number of comments for the video.
	CommentCount uint64 `json:"commentCount,omitempty,string"`
	// DislikeCount: The number of users who have indicated that they disliked the
	// video by giving it a negative rating.
	DislikeCount uint64 `json:"dislikeCount,omitempty,string"`
	// FavoriteCount: The number of users who currently have the video marked as a
	// favorite video.
	FavoriteCount uint64 `json:"favoriteCount,omitempty,string"`
	// LikeCount: The number of users who have indicated that they liked the video
	// by giving it a positive rating.
	LikeCount uint64 `json:"likeCount,omitempty,string"`
	// ViewCount: The number of times the video 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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStatistics) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStatistics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStatsContentDetails: Details about the content of a YouTube Video. This
// is a subset of the information in VideoContentDetails specifically for the
// Videos.stats API.
type VideoStatsContentDetails struct {
	// Duration: Output only. The length of the video. The property value is a
	// `google.protobuf.Duration`
	// (https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#duration)
	// object.
	Duration string `json:"duration,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Duration") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Duration") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStatsContentDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStatsContentDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStatsSnippet: Basic details about a video. This is a subset of the
// information in VideoSnippet specifically for the Videos.stats API.
type VideoStatsSnippet struct {
	// PublishTime: Output only. The date and time that the video was uploaded. The
	// property value is a `google.protobuf.Timestamp`
	// (https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#timestamp)
	// object.
	PublishTime string `json:"publishTime,omitempty"`
	// ForceSendFields is a list of field names (e.g. "PublishTime") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "PublishTime") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStatsSnippet) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStatsSnippet
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStatsStatistics: Statistics about the video, such as the number of
// times the video was viewed or liked.
type VideoStatsStatistics struct {
	// CommentCount: Output only. The number of comments for the video.
	CommentCount int64 `json:"commentCount,omitempty,string"`
	// LikeCount: Output only. The number of users who have indicated that they
	// liked the video by giving it a positive rating.
	LikeCount int64 `json:"likeCount,omitempty,string"`
	// ViewCount: Output only. The number of times the video has been viewed.
	ViewCount int64 `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 or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStatsStatistics) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStatsStatistics
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoStatus: Basic details about a video category, such as its localized
// title. Next Id: 20
type VideoStatus struct {
	// ContainsSyntheticMedia: Indicates if the video contains altered or synthetic
	// media.
	ContainsSyntheticMedia bool `json:"containsSyntheticMedia,omitempty"`
	// Embeddable: This value indicates if the video can be embedded on another
	// website. @mutable youtube.videos.insert youtube.videos.update
	Embeddable bool `json:"embeddable,omitempty"`
	// FailureReason: This value explains why a video failed to upload. This
	// property is only present if the `uploadStatus` property indicates that the
	// upload failed.
	//
	// Possible values:
	//   "conversion" - Unable to convert video content.
	//   "invalidFile" - Invalid file format.
	//   "emptyFile" - Empty file.
	//   "tooSmall" - File was too small.
	//   "codec" - Unsupported codec.
	//   "uploadAborted" - Upload wasn't finished.
	FailureReason string `json:"failureReason,omitempty"`
	// License: The video's license. @mutable youtube.videos.insert
	// youtube.videos.update
	//
	// Possible values:
	//   "youtube" - Standard YouTube license.
	//   "creativeCommon" - Creative Commons license.
	License     string `json:"license,omitempty"`
	MadeForKids bool   `json:"madeForKids,omitempty"`
	// PrivacyStatus: The video's privacy status. In a `videos.insert` request, if
	// you don't specify a value for this property, the uploaded video's privacy
	// status defaults to `public`. Certain uploads might default to `private`
	// based on creator account settings, as explained in the YouTube Help Center
	// (https://support.google.com/youtube/answer/157177). Videos uploaded from
	// unverified API projects are not restricted to private viewing mode.
	//
	// Possible values:
	//   "public"
	//   "unlisted"
	//   "private"
	PrivacyStatus string `json:"privacyStatus,omitempty"`
	// PublicStatsViewable: This value indicates if the extended video statistics
	// on the watch page can be viewed by everyone. Note that the view count,
	// likes, etc will still be visible if this is disabled. @mutable
	// youtube.videos.insert youtube.videos.update
	PublicStatsViewable bool `json:"publicStatsViewable,omitempty"`
	// PublishAt: The date and time when the video is scheduled to publish. It can
	// be set only if the privacy status of the video is private..
	PublishAt string `json:"publishAt,omitempty"`
	// RejectionReason: This value explains why YouTube rejected an uploaded video.
	// This property is only present if the `uploadStatus` property indicates that
	// the upload was rejected.
	//
	// Possible values:
	//   "copyright" - Copyright infringement.
	//   "inappropriate" - Inappropriate video content.
	//   "duplicate" - Duplicate upload in the same channel.
	//   "termsOfUse" - Terms of use violation.
	//   "uploaderAccountSuspended" - Uploader account was suspended.
	//   "length" - Video duration was too long.
	//   "claim" - Blocked by content owner.
	//   "uploaderAccountClosed" - Uploader closed his/her account.
	//   "trademark" - Trademark infringement.
	//   "legal" - An unspecified legal reason.
	RejectionReason         string `json:"rejectionReason,omitempty"`
	SelfDeclaredMadeForKids bool   `json:"selfDeclaredMadeForKids,omitempty"`
	// UploadStatus: The status of the uploaded video.
	//
	// Possible values:
	//   "uploaded" - Video has been uploaded but not processed yet.
	//   "processed" - Video has been successfully processed.
	//   "failed" - Processing has failed. See FailureReason.
	//   "rejected" - Video has been rejected. See RejectionReason.
	//   "deleted" - Video has been deleted.
	UploadStatus string `json:"uploadStatus,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ContainsSyntheticMedia") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ContainsSyntheticMedia") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoStatus) MarshalJSON() ([]byte, error) {
	type NoMethod VideoStatus
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoSuggestions: Specifies suggestions on how to improve video content,
// including encoding hints, tag suggestions, and editor suggestions.
type VideoSuggestions struct {
	// EditorSuggestions: A list of video editing operations that might improve the
	// video quality or playback experience of the uploaded video.
	//
	// Possible values:
	//   "videoAutoLevels" - Picture brightness levels seem off and could be
	// corrected.
	//   "videoStabilize" - The video appears shaky and could be stabilized.
	//   "videoCrop" - Margins (mattes) detected around the picture could be
	// cropped.
	//   "audioQuietAudioSwap" - The audio track appears silent and could be
	// swapped with a better quality one.
	EditorSuggestions []string `json:"editorSuggestions,omitempty"`
	// ProcessingErrors: A list of errors that will prevent YouTube from
	// successfully processing the uploaded video video. These errors indicate
	// that, regardless of the video's current processing status, eventually, that
	// status will almost certainly be failed.
	//
	// Possible values:
	//   "audioFile" - File contains audio only (e.g., an MP3 file).
	//   "imageFile" - Image file (e.g., a JPEG image).
	//   "projectFile" - Movie project file (e.g., Microsoft Windows Movie Maker
	// project).
	//   "notAVideoFile" - Other non-video file.
	//   "docFile" - Document or text file (e.g., MS Word document).
	//   "archiveFile" - An archive file (e.g., a ZIP archive).
	//   "unsupportedSpatialAudioLayout" - Unsupported spatial audio layout type.
	ProcessingErrors []string `json:"processingErrors,omitempty"`
	// ProcessingHints: A list of suggestions that may improve YouTube's ability to
	// process the video.
	//
	// Possible values:
	//   "nonStreamableMov" - The MP4 file is not streamable, this will slow down
	// the processing. MOOV atom was not found at the beginning of the file.
	//   "sendBestQualityVideo" - Probably a better quality version of the video
	// exists. The video has wide screen aspect ratio, but is not an HD video.
	//   "sphericalVideo" - Uploaded video is spherical video.
	//   "spatialAudio" - Uploaded video has spatial audio.
	//   "vrVideo" - Uploaded video is VR video.
	//   "hdrVideo" - Uploaded video is HDR video.
	ProcessingHints []string `json:"processingHints,omitempty"`
	// ProcessingWarnings: A list of reasons why YouTube may have difficulty
	// transcoding the uploaded video or that might result in an erroneous
	// transcoding. These warnings are generated before YouTube actually processes
	// the uploaded video file. In addition, they identify issues that are unlikely
	// to cause the video processing to fail but that might cause problems such as
	// sync issues, video artifacts, or a missing audio track.
	//
	// Possible values:
	//   "unknownContainer" - Unrecognized file format, transcoding is likely to
	// fail.
	//   "unknownVideoCodec" - Unrecognized video codec, transcoding is likely to
	// fail.
	//   "unknownAudioCodec" - Unrecognized audio codec, transcoding is likely to
	// fail.
	//   "inconsistentResolution" - Conflicting container and stream resolutions.
	//   "hasEditlist" - Edit lists are not currently supported.
	//   "problematicVideoCodec" - Video codec that is known to cause problems was
	// used.
	//   "problematicAudioCodec" - Audio codec that is known to cause problems was
	// used.
	//   "unsupportedVrStereoMode" - Unsupported VR video stereo mode.
	//   "unsupportedSphericalProjectionType" - Unsupported spherical video
	// projection type.
	//   "unsupportedHdrPixelFormat" - Unsupported HDR pixel format.
	//   "unsupportedHdrColorMetadata" - Unspecified HDR color metadata.
	//   "problematicHdrLookupTable" - Problematic HDR lookup table attached.
	ProcessingWarnings []string `json:"processingWarnings,omitempty"`
	// TagSuggestions: A list of keyword tags that could be added to the video's
	// metadata to increase the likelihood that users will locate your video when
	// searching or browsing on YouTube.
	TagSuggestions []*VideoSuggestionsTagSuggestion `json:"tagSuggestions,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EditorSuggestions") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EditorSuggestions") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoSuggestions) MarshalJSON() ([]byte, error) {
	type NoMethod VideoSuggestions
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoSuggestionsTagSuggestion: A single tag suggestion with its relevance
// information.
type VideoSuggestionsTagSuggestion struct {
	// CategoryRestricts: A set of video categories for which the tag is relevant.
	// You can use this information to display appropriate tag suggestions based on
	// the video category that the video uploader associates with the video. By
	// default, tag suggestions are relevant for all categories if there are no
	// restricts defined for the keyword.
	CategoryRestricts []string `json:"categoryRestricts,omitempty"`
	// Tag: The keyword tag suggested for the video.
	Tag string `json:"tag,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CategoryRestricts") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CategoryRestricts") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoSuggestionsTagSuggestion) MarshalJSON() ([]byte, error) {
	type NoMethod VideoSuggestionsTagSuggestion
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoTopicDetails: Freebase topic information related to the video.
type VideoTopicDetails struct {
	// RelevantTopicIds: Similar to topic_id, except that these topics are merely
	// relevant to the video. These are topics that may be mentioned in, or appear
	// in the video. You can retrieve information about each topic using Freebase
	// Topic API.
	RelevantTopicIds []string `json:"relevantTopicIds,omitempty"`
	// TopicCategories: A list of Wikipedia URLs that provide a high-level
	// description of the video's content.
	TopicCategories []string `json:"topicCategories,omitempty"`
	// TopicIds: A list of Freebase topic IDs that are centrally associated with
	// the video. These are topics that are centrally featured in the video, and it
	// can be said that the video is mainly about each of these. You can retrieve
	// information about each topic using the < a
	// href="http://wiki.freebase.com/wiki/Topic_API">Freebase Topic API.
	TopicIds []string `json:"topicIds,omitempty"`
	// ForceSendFields is a list of field names (e.g. "RelevantTopicIds") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "RelevantTopicIds") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoTopicDetails) MarshalJSON() ([]byte, error) {
	type NoMethod VideoTopicDetails
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// VideoTrainability: Specifies who is allowed to train on the video.
type VideoTrainability struct {
	// Etag: Etag of this resource.
	Etag string `json:"etag,omitempty"`
	// Kind: Identifies what kind of resource this is. Value: the fixed string
	// "youtube#videoTrainability".
	Kind string `json:"kind,omitempty"`
	// Permitted: Specifies who is allowed to train on the video. Valid values are:
	// - a single string "all" - a single string "none" - a list of allowed parties
	Permitted []string `json:"permitted,omitempty"`
	// VideoId: The ID of the video.
	VideoId string `json:"videoId,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 or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	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. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s VideoTrainability) MarshalJSON() ([]byte, error) {
	type NoMethod VideoTrainability
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

// WatchSettings: Branding properties for the watch. All deprecated.
type WatchSettings struct {
	// BackgroundColor: The text color for the video watch page's branded area.
	BackgroundColor string `json:"backgroundColor,omitempty"`
	// FeaturedPlaylistId: An ID that uniquely identifies a playlist that displays
	// next to the video player.
	FeaturedPlaylistId string `json:"featuredPlaylistId,omitempty"`
	// TextColor: The background color for the video watch page's branded area.
	TextColor string `json:"textColor,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BackgroundColor") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BackgroundColor") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

func (s WatchSettings) MarshalJSON() ([]byte, error) {
	type NoMethod WatchSettings
	return gensupport.MarshalJSON(NoMethod(s), s.ForceSendFields, s.NullFields)
}

type AbuseReportsInsertCall struct {
	s           *Service
	abusereport *AbuseReport
	urlParams_  gensupport.URLParams
	ctx_        context.Context
	header_     http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include.
func (r *AbuseReportsService) Insert(part []string, abusereport *AbuseReport) *AbuseReportsInsertCall {
	c := &AbuseReportsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.abusereport = abusereport
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *AbuseReportsInsertCall) Fields(s ...googleapi.Field) *AbuseReportsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *AbuseReportsInsertCall) Context(ctx context.Context) *AbuseReportsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *AbuseReportsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *AbuseReportsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.abusereport)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/abuseReports")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.abuseReports.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.abuseReports.insert" call.
// 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 (c *AbuseReportsInsertCall) Do(opts ...googleapi.CallOption) (*AbuseReport, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &AbuseReport{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.abuseReports.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ActivitiesListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     activity resource properties that the API response will include. If the
//     parameter identifies a property that contains child properties, the child
//     properties will be included in the response. For example, in an activity
//     resource, the snippet property contains other properties that identify the
//     type of activity, a display title for the activity, and so forth. If you
//     set *part=snippet*, the API response will also contain all of those nested
//     properties.
func (r *ActivitiesService) List(part []string) *ActivitiesListCall {
	c := &ActivitiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ChannelId sets the optional parameter "channelId":
func (c *ActivitiesListCall) ChannelId(channelId string) *ActivitiesListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// Home sets the optional parameter "home":
func (c *ActivitiesListCall) Home(home bool) *ActivitiesListCall {
	c.urlParams_.Set("home", fmt.Sprint(home))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *ActivitiesListCall) MaxResults(maxResults int64) *ActivitiesListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine":
func (c *ActivitiesListCall) Mine(mine bool) *ActivitiesListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// 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 (c *ActivitiesListCall) PageToken(pageToken string) *ActivitiesListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// PublishedAfter sets the optional parameter "publishedAfter":
func (c *ActivitiesListCall) PublishedAfter(publishedAfter string) *ActivitiesListCall {
	c.urlParams_.Set("publishedAfter", publishedAfter)
	return c
}

// PublishedBefore sets the optional parameter "publishedBefore":
func (c *ActivitiesListCall) PublishedBefore(publishedBefore string) *ActivitiesListCall {
	c.urlParams_.Set("publishedBefore", publishedBefore)
	return c
}

// RegionCode sets the optional parameter "regionCode":
func (c *ActivitiesListCall) RegionCode(regionCode string) *ActivitiesListCall {
	c.urlParams_.Set("regionCode", regionCode)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ActivitiesListCall) Fields(s ...googleapi.Field) *ActivitiesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ActivitiesListCall) IfNoneMatch(entityTag string) *ActivitiesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ActivitiesListCall) Context(ctx context.Context) *ActivitiesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ActivitiesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ActivitiesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/activities")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.activities.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.activities.list" call.
// 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 (c *ActivitiesListCall) Do(opts ...googleapi.CallOption) (*ActivityListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ActivityListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.activities.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *ActivitiesListCall) Pages(ctx context.Context, f func(*ActivityListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type CaptionsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *CaptionsService) Delete(id string) *CaptionsDeleteCall {
	c := &CaptionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page
// for the channel that the request is be on behalf of
func (c *CaptionsDeleteCall) OnBehalfOf(onBehalfOf string) *CaptionsDeleteCall {
	c.urlParams_.Set("onBehalfOf", onBehalfOf)
	return c
}

// 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 (c *CaptionsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CaptionsDeleteCall) Fields(s ...googleapi.Field) *CaptionsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CaptionsDeleteCall) Context(ctx context.Context) *CaptionsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CaptionsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CaptionsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/captions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.captions.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.captions.delete" call.
func (c *CaptionsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.captions.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type CaptionsDownloadCall struct {
	s            *Service
	id           string
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Download: Downloads a caption track.
//
// - id: The ID of the caption track to download, required for One Platform.
func (r *CaptionsService) Download(id string) *CaptionsDownloadCall {
	c := &CaptionsDownloadCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.id = id
	return c
}

// OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page
// for the channel that the request is be on behalf of
func (c *CaptionsDownloadCall) OnBehalfOf(onBehalfOf string) *CaptionsDownloadCall {
	c.urlParams_.Set("onBehalfOf", onBehalfOf)
	return c
}

// 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 (c *CaptionsDownloadCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsDownloadCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Tfmt sets the optional parameter "tfmt": Convert the captions into this
// format. Supported options are sbv, srt, and vtt.
func (c *CaptionsDownloadCall) Tfmt(tfmt string) *CaptionsDownloadCall {
	c.urlParams_.Set("tfmt", tfmt)
	return c
}

// Tlang sets the optional parameter "tlang": tlang is the language code;
// machine translate the captions into this language.
func (c *CaptionsDownloadCall) Tlang(tlang string) *CaptionsDownloadCall {
	c.urlParams_.Set("tlang", tlang)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CaptionsDownloadCall) Fields(s ...googleapi.Field) *CaptionsDownloadCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *CaptionsDownloadCall) IfNoneMatch(entityTag string) *CaptionsDownloadCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do and Download methods.
func (c *CaptionsDownloadCall) Context(ctx context.Context) *CaptionsDownloadCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CaptionsDownloadCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CaptionsDownloadCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/captions/{id}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"id": c.id,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.captions.download", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// 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 (c *CaptionsDownloadCall) Download(opts ...googleapi.CallOption) (*http.Response, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("media")
	if err != nil {
		return nil, err
	}
	if err := googleapi.CheckResponse(res); err != nil {
		res.Body.Close()
		return nil, gensupport.WrapError(err)
	}
	return res, nil
}

// Do executes the "youtube.captions.download" call.
func (c *CaptionsDownloadCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.captions.download", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type CaptionsInsertCall struct {
	s          *Service
	caption    *Caption
	urlParams_ gensupport.URLParams
	mediaInfo_ *gensupport.MediaInfo
	ctx_       context.Context
	header_    http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter specifies the caption resource parts that the
//     API response will include. Set the parameter value to snippet.
func (r *CaptionsService) Insert(part []string, caption *Caption) *CaptionsInsertCall {
	c := &CaptionsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.caption = caption
	return c
}

// OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page
// for the channel that the request is be on behalf of
func (c *CaptionsInsertCall) OnBehalfOf(onBehalfOf string) *CaptionsInsertCall {
	c.urlParams_.Set("onBehalfOf", onBehalfOf)
	return c
}

// 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 (c *CaptionsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Sync sets the optional parameter "sync": Extra parameter to allow
// automatically syncing the uploaded caption/transcript with the audio.
func (c *CaptionsInsertCall) Sync(sync bool) *CaptionsInsertCall {
	c.urlParams_.Set("sync", fmt.Sprint(sync))
	return c
}

// 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 (c *CaptionsInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *CaptionsInsertCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *CaptionsInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *CaptionsInsertCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *CaptionsInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *CaptionsInsertCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CaptionsInsertCall) Fields(s ...googleapi.Field) *CaptionsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *CaptionsInsertCall) Context(ctx context.Context) *CaptionsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CaptionsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CaptionsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.caption)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/captions")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/captions")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.captions.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.captions.insert" call.
// 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 (c *CaptionsInsertCall) Do(opts ...googleapi.CallOption) (*Caption, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &Caption{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.captions.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type CaptionsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     caption resource parts that the API response will include. The part names
//     that you can include in the parameter value are id and snippet.
//   - videoId: Returns the captions for the specified video.
func (r *CaptionsService) List(part []string, videoId string) *CaptionsListCall {
	c := &CaptionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.urlParams_.Set("videoId", videoId)
	return c
}

// Id sets the optional parameter "id": Returns the captions with the given IDs
// for Stubby or Apiary.
func (c *CaptionsListCall) Id(id ...string) *CaptionsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page
// for the channel that the request is on behalf of.
func (c *CaptionsListCall) OnBehalfOf(onBehalfOf string) *CaptionsListCall {
	c.urlParams_.Set("onBehalfOf", onBehalfOf)
	return c
}

// 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 (c *CaptionsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CaptionsListCall) Fields(s ...googleapi.Field) *CaptionsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *CaptionsListCall) IfNoneMatch(entityTag string) *CaptionsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CaptionsListCall) Context(ctx context.Context) *CaptionsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CaptionsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CaptionsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/captions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.captions.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.captions.list" call.
// 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 (c *CaptionsListCall) Do(opts ...googleapi.CallOption) (*CaptionListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &CaptionListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.captions.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type CaptionsUpdateCall struct {
	s          *Service
	caption    *Caption
	urlParams_ gensupport.URLParams
	mediaInfo_ *gensupport.MediaInfo
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     caption resource parts that the API response will include. The part names
//     that you can include in the parameter value are id and snippet.
func (r *CaptionsService) Update(part []string, caption *Caption) *CaptionsUpdateCall {
	c := &CaptionsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.caption = caption
	return c
}

// OnBehalfOf sets the optional parameter "onBehalfOf": ID of the Google+ Page
// for the channel that the request is on behalf of.
func (c *CaptionsUpdateCall) OnBehalfOf(onBehalfOf string) *CaptionsUpdateCall {
	c.urlParams_.Set("onBehalfOf", onBehalfOf)
	return c
}

// 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 (c *CaptionsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *CaptionsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Sync sets the optional parameter "sync": Extra parameter to allow
// automatically syncing the uploaded caption/transcript with the audio.
func (c *CaptionsUpdateCall) Sync(sync bool) *CaptionsUpdateCall {
	c.urlParams_.Set("sync", fmt.Sprint(sync))
	return c
}

// 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 (c *CaptionsUpdateCall) Media(r io.Reader, options ...googleapi.MediaOption) *CaptionsUpdateCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *CaptionsUpdateCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *CaptionsUpdateCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *CaptionsUpdateCall) ProgressUpdater(pu googleapi.ProgressUpdater) *CaptionsUpdateCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CaptionsUpdateCall) Fields(s ...googleapi.Field) *CaptionsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *CaptionsUpdateCall) Context(ctx context.Context) *CaptionsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CaptionsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CaptionsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.caption)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/captions")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/captions")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.captions.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.captions.update" call.
// 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 (c *CaptionsUpdateCall) Do(opts ...googleapi.CallOption) (*Caption, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &Caption{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.captions.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ChannelBannersInsertCall struct {
	s                     *Service
	channelbannerresource *ChannelBannerResource
	urlParams_            gensupport.URLParams
	mediaInfo_            *gensupport.MediaInfo
	ctx_                  context.Context
	header_               http.Header
}

// Insert: Inserts a new resource into this collection.
func (r *ChannelBannersService) Insert(channelbannerresource *ChannelBannerResource) *ChannelBannersInsertCall {
	c := &ChannelBannersInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.channelbannerresource = channelbannerresource
	return c
}

// ChannelId sets the optional parameter "channelId": Unused, channel_id is
// currently derived from the security context of the requestor.
func (c *ChannelBannersInsertCall) ChannelId(channelId string) *ChannelBannersInsertCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// 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 (c *ChannelBannersInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelBannersInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *ChannelBannersInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *ChannelBannersInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// 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 (c *ChannelBannersInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *ChannelBannersInsertCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *ChannelBannersInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *ChannelBannersInsertCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *ChannelBannersInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *ChannelBannersInsertCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelBannersInsertCall) Fields(s ...googleapi.Field) *ChannelBannersInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *ChannelBannersInsertCall) Context(ctx context.Context) *ChannelBannersInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelBannersInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelBannersInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.channelbannerresource)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channelBanners/insert")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/channelBanners/insert")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channelBanners.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channelBanners.insert" call.
// 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 (c *ChannelBannersInsertCall) Do(opts ...googleapi.CallOption) (*ChannelBannerResource, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &ChannelBannerResource{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channelBanners.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ChannelSectionsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *ChannelSectionsService) Delete(id string) *ChannelSectionsDeleteCall {
	c := &ChannelSectionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *ChannelSectionsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelSectionsDeleteCall) Fields(s ...googleapi.Field) *ChannelSectionsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelSectionsDeleteCall) Context(ctx context.Context) *ChannelSectionsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelSectionsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelSectionsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channelSections")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channelSections.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channelSections.delete" call.
func (c *ChannelSectionsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channelSections.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type ChannelSectionsInsertCall struct {
	s              *Service
	channelsection *ChannelSection
	urlParams_     gensupport.URLParams
	ctx_           context.Context
	header_        http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part names that you can
//     include in the parameter value are snippet and contentDetails.
func (r *ChannelSectionsService) Insert(part []string, channelsection *ChannelSection) *ChannelSectionsInsertCall {
	c := &ChannelSectionsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.channelsection = channelsection
	return c
}

// 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 (c *ChannelSectionsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *ChannelSectionsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *ChannelSectionsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelSectionsInsertCall) Fields(s ...googleapi.Field) *ChannelSectionsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelSectionsInsertCall) Context(ctx context.Context) *ChannelSectionsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelSectionsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelSectionsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.channelsection)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channelSections")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channelSections.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channelSections.insert" call.
// 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 (c *ChannelSectionsInsertCall) Do(opts ...googleapi.CallOption) (*ChannelSection, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ChannelSection{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channelSections.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ChannelSectionsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     channelSection resource properties that the API response will include. The
//     part names that you can include in the parameter value are id, snippet,
//     and contentDetails. If the parameter identifies a property that contains
//     child properties, the child properties will be included in the response.
//     For example, in a channelSection resource, the snippet property contains
//     other properties, such as a display title for the channelSection. If you
//     set *part=snippet*, the API response will also contain all of those nested
//     properties.
func (r *ChannelSectionsService) List(part []string) *ChannelSectionsListCall {
	c := &ChannelSectionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ChannelId sets the optional parameter "channelId": Return the
// ChannelSections owned by the specified channel ID.
func (c *ChannelSectionsListCall) ChannelId(channelId string) *ChannelSectionsListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// Hl sets the optional parameter "hl": Return content in specified language
func (c *ChannelSectionsListCall) Hl(hl string) *ChannelSectionsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Id sets the optional parameter "id": Return the ChannelSections with the
// given IDs for Stubby or Apiary.
func (c *ChannelSectionsListCall) Id(id ...string) *ChannelSectionsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// Mine sets the optional parameter "mine": Return the ChannelSections owned by
// the authenticated user.
func (c *ChannelSectionsListCall) Mine(mine bool) *ChannelSectionsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// 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 (c *ChannelSectionsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelSectionsListCall) Fields(s ...googleapi.Field) *ChannelSectionsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ChannelSectionsListCall) IfNoneMatch(entityTag string) *ChannelSectionsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelSectionsListCall) Context(ctx context.Context) *ChannelSectionsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelSectionsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelSectionsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channelSections")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channelSections.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channelSections.list" call.
// 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 (c *ChannelSectionsListCall) Do(opts ...googleapi.CallOption) (*ChannelSectionListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ChannelSectionListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channelSections.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ChannelSectionsUpdateCall struct {
	s              *Service
	channelsection *ChannelSection
	urlParams_     gensupport.URLParams
	ctx_           context.Context
	header_        http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part names that you can
//     include in the parameter value are snippet and contentDetails.
func (r *ChannelSectionsService) Update(part []string, channelsection *ChannelSection) *ChannelSectionsUpdateCall {
	c := &ChannelSectionsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.channelsection = channelsection
	return c
}

// 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 (c *ChannelSectionsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelSectionsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelSectionsUpdateCall) Fields(s ...googleapi.Field) *ChannelSectionsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelSectionsUpdateCall) Context(ctx context.Context) *ChannelSectionsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelSectionsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelSectionsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.channelsection)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channelSections")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channelSections.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channelSections.update" call.
// 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 (c *ChannelSectionsUpdateCall) Do(opts ...googleapi.CallOption) (*ChannelSection, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ChannelSection{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channelSections.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ChannelsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     channel resource properties that the API response will include. If the
//     parameter identifies a property that contains child properties, the child
//     properties will be included in the response. For example, in a channel
//     resource, the contentDetails property contains other properties, such as
//     the uploads properties. As such, if you set *part=contentDetails*, the API
//     response will also contain all of those nested properties.
func (r *ChannelsService) List(part []string) *ChannelsListCall {
	c := &ChannelsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// CategoryId sets the optional parameter "categoryId": Return the channels
// within the specified guide category ID.
func (c *ChannelsListCall) CategoryId(categoryId string) *ChannelsListCall {
	c.urlParams_.Set("categoryId", categoryId)
	return c
}

// ForHandle sets the optional parameter "forHandle": Return the channel
// associated with a YouTube handle.
func (c *ChannelsListCall) ForHandle(forHandle string) *ChannelsListCall {
	c.urlParams_.Set("forHandle", forHandle)
	return c
}

// ForUsername sets the optional parameter "forUsername": Return the channel
// associated with a YouTube username.
func (c *ChannelsListCall) ForUsername(forUsername string) *ChannelsListCall {
	c.urlParams_.Set("forUsername", forUsername)
	return c
}

// 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 (c *ChannelsListCall) Hl(hl string) *ChannelsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Id sets the optional parameter "id": Return the channels with the specified
// IDs.
func (c *ChannelsListCall) Id(id ...string) *ChannelsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// ManagedByMe sets the optional parameter "managedByMe": Return the channels
// managed by the authenticated user.
func (c *ChannelsListCall) ManagedByMe(managedByMe bool) *ChannelsListCall {
	c.urlParams_.Set("managedByMe", fmt.Sprint(managedByMe))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *ChannelsListCall) MaxResults(maxResults int64) *ChannelsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine": Return the ids of channels owned by
// the authenticated user.
func (c *ChannelsListCall) Mine(mine bool) *ChannelsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// MySubscribers sets the optional parameter "mySubscribers": Return the
// channels subscribed to the authenticated user
func (c *ChannelsListCall) MySubscribers(mySubscribers bool) *ChannelsListCall {
	c.urlParams_.Set("mySubscribers", fmt.Sprint(mySubscribers))
	return c
}

// 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 (c *ChannelsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// 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 (c *ChannelsListCall) PageToken(pageToken string) *ChannelsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelsListCall) Fields(s ...googleapi.Field) *ChannelsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ChannelsListCall) IfNoneMatch(entityTag string) *ChannelsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelsListCall) Context(ctx context.Context) *ChannelsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channels")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channels.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channels.list" call.
// 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 (c *ChannelsListCall) Do(opts ...googleapi.CallOption) (*ChannelListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ChannelListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channels.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *ChannelsListCall) Pages(ctx context.Context, f func(*ChannelListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type ChannelsUpdateCall struct {
	s          *Service
	channel    *Channel
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The API currently only
//     allows the parameter value to be set to either brandingSettings or
//     invideoPromotion. (You cannot update both of those parts with a single
//     request.) Note that this method overrides the existing values for all of
//     the mutable properties that are contained in any parts that the parameter
//     value specifies.
func (r *ChannelsService) Update(part []string, channel *Channel) *ChannelsUpdateCall {
	c := &ChannelsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.channel = channel
	return c
}

// OnBehalfOfContentOwner sets the optional parameter "onBehalfOfContentOwner":
// The *onBehalfOfContentOwner* parameter indicates that the authenticated user
// is acting on behalf of the content owner specified in the parameter value.
// This parameter is intended for YouTube content partners that own and manage
// many different YouTube channels. It allows content owners to authenticate
// once and get access to all their video and channel data, without having to
// provide authentication credentials for each individual channel. The actual
// CMS account that the user authenticates with needs to be linked to the
// specified YouTube content owner. This parameter must be provided if the
// request is authenticated with credentials for a CMS content owner user
// acting on a managed channel. If omitted, the request executes under the
// authenticated user's direct context and returns an HTTP 403 Forbidden error.
func (c *ChannelsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ChannelsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ChannelsUpdateCall) Fields(s ...googleapi.Field) *ChannelsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ChannelsUpdateCall) Context(ctx context.Context) *ChannelsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ChannelsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ChannelsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.channel)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/channels")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.channels.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.channels.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *Channel.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 (c *ChannelsUpdateCall) Do(opts ...googleapi.CallOption) (*Channel, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Channel{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.channels.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type CommentThreadsInsertCall struct {
	s             *Service
	commentthread *CommentThread
	urlParams_    gensupport.URLParams
	ctx_          context.Context
	header_       http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter identifies the properties that the API response
//     will include. Set the parameter value to snippet. The snippet part has a
//     quota cost of 2 units.
func (r *CommentThreadsService) Insert(part []string, commentthread *CommentThread) *CommentThreadsInsertCall {
	c := &CommentThreadsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.commentthread = commentthread
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentThreadsInsertCall) Fields(s ...googleapi.Field) *CommentThreadsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentThreadsInsertCall) Context(ctx context.Context) *CommentThreadsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentThreadsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentThreadsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.commentthread)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/commentThreads")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.commentThreads.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.commentThreads.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *CommentThread.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 (c *CommentThreadsInsertCall) Do(opts ...googleapi.CallOption) (*CommentThread, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &CommentThread{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.commentThreads.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type CommentThreadsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     commentThread resource properties that the API response will include.
func (r *CommentThreadsService) List(part []string) *CommentThreadsListCall {
	c := &CommentThreadsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// AllThreadsRelatedToChannelId sets the optional parameter
// "allThreadsRelatedToChannelId": Returns the comment threads of all videos of
// the channel and the channel comments as well.
func (c *CommentThreadsListCall) AllThreadsRelatedToChannelId(allThreadsRelatedToChannelId string) *CommentThreadsListCall {
	c.urlParams_.Set("allThreadsRelatedToChannelId", allThreadsRelatedToChannelId)
	return c
}

// ChannelId sets the optional parameter "channelId": Returns the comment
// threads for all the channel comments (ie does not include comments left on
// videos).
func (c *CommentThreadsListCall) ChannelId(channelId string) *CommentThreadsListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// Id sets the optional parameter "id": Returns the comment threads with the
// given IDs for Stubby or Apiary.
func (c *CommentThreadsListCall) Id(id ...string) *CommentThreadsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *CommentThreadsListCall) MaxResults(maxResults int64) *CommentThreadsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// ModerationStatus sets the optional parameter "moderationStatus": Limits the
// returned comment threads to those with the specified moderation status. Not
// compatible with the 'id' filter. Valid values: published, heldForReview,
// likelySpam.
//
// Possible values:
//
//	"published" (default) - The comment is available for public display.
//	"heldForReview" - The comment is awaiting review by a moderator.
//	"likelySpam"
//	"rejected" - The comment is unfit for display.
func (c *CommentThreadsListCall) ModerationStatus(moderationStatus string) *CommentThreadsListCall {
	c.urlParams_.Set("moderationStatus", moderationStatus)
	return c
}

// Order sets the optional parameter "order":
//
// Possible values:
//
//	"orderUnspecified"
//	"time" (default) - Order by time.
//	"relevance" - Order by relevance.
func (c *CommentThreadsListCall) Order(order string) *CommentThreadsListCall {
	c.urlParams_.Set("order", order)
	return c
}

// 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 (c *CommentThreadsListCall) PageToken(pageToken string) *CommentThreadsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// SearchTerms sets the optional parameter "searchTerms": Limits the returned
// comment threads to those matching the specified key words. Not compatible
// with the 'id' filter.
func (c *CommentThreadsListCall) SearchTerms(searchTerms string) *CommentThreadsListCall {
	c.urlParams_.Set("searchTerms", searchTerms)
	return c
}

// TextFormat sets the optional parameter "textFormat": The requested text
// format for the returned comments.
//
// Possible values:
//
//	"textFormatUnspecified"
//	"html" (default) - Returns the comments in HTML format. This is the
//
// default value.
//
//	"plainText" - Returns the comments in plain text format.
func (c *CommentThreadsListCall) TextFormat(textFormat string) *CommentThreadsListCall {
	c.urlParams_.Set("textFormat", textFormat)
	return c
}

// VideoId sets the optional parameter "videoId": Returns the comment threads
// of the specified video.
func (c *CommentThreadsListCall) VideoId(videoId string) *CommentThreadsListCall {
	c.urlParams_.Set("videoId", videoId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentThreadsListCall) Fields(s ...googleapi.Field) *CommentThreadsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *CommentThreadsListCall) IfNoneMatch(entityTag string) *CommentThreadsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentThreadsListCall) Context(ctx context.Context) *CommentThreadsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentThreadsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentThreadsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/commentThreads")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.commentThreads.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.commentThreads.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *CommentThreadListResponse.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 (c *CommentThreadsListCall) Do(opts ...googleapi.CallOption) (*CommentThreadListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &CommentThreadListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.commentThreads.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *CommentThreadsListCall) Pages(ctx context.Context, f func(*CommentThreadListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type CommentsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *CommentsService) Delete(id string) *CommentsDeleteCall {
	c := &CommentsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsDeleteCall) Fields(s ...googleapi.Field) *CommentsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsDeleteCall) Context(ctx context.Context) *CommentsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.delete" call.
func (c *CommentsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type CommentsInsertCall struct {
	s          *Service
	comment    *Comment
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter identifies the properties that the API response
//     will include. Set the parameter value to snippet. The snippet part has a
//     quota cost of 2 units.
func (r *CommentsService) Insert(part []string, comment *Comment) *CommentsInsertCall {
	c := &CommentsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.comment = comment
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsInsertCall) Fields(s ...googleapi.Field) *CommentsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsInsertCall) Context(ctx context.Context) *CommentsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.comment)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *Comment.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 (c *CommentsInsertCall) Do(opts ...googleapi.CallOption) (*Comment, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Comment{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type CommentsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     comment resource properties that the API response will include.
func (r *CommentsService) List(part []string) *CommentsListCall {
	c := &CommentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Id sets the optional parameter "id": Returns the comments with the given IDs
// for One Platform.
func (c *CommentsListCall) Id(id ...string) *CommentsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *CommentsListCall) MaxResults(maxResults int64) *CommentsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *CommentsListCall) PageToken(pageToken string) *CommentsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// ParentId sets the optional parameter "parentId": Returns replies to the
// specified comment. Note, currently YouTube features only one level of
// replies (ie replies to top level comments). However replies to replies may
// be supported in the future.
func (c *CommentsListCall) ParentId(parentId string) *CommentsListCall {
	c.urlParams_.Set("parentId", parentId)
	return c
}

// TextFormat sets the optional parameter "textFormat": The requested text
// format for the returned comments.
//
// Possible values:
//
//	"textFormatUnspecified"
//	"html" (default) - Returns the comments in HTML format. This is the
//
// default value.
//
//	"plainText" - Returns the comments in plain text format.
func (c *CommentsListCall) TextFormat(textFormat string) *CommentsListCall {
	c.urlParams_.Set("textFormat", textFormat)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsListCall) Fields(s ...googleapi.Field) *CommentsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *CommentsListCall) IfNoneMatch(entityTag string) *CommentsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsListCall) Context(ctx context.Context) *CommentsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *CommentListResponse.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 (c *CommentsListCall) Do(opts ...googleapi.CallOption) (*CommentListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &CommentListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *CommentsListCall) Pages(ctx context.Context, f func(*CommentListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type CommentsMarkAsSpamCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// MarkAsSpam: Expresses the caller's opinion that one or more comments should
// be flagged as spam.
//
// - id: Flags the comments with the given IDs as spam in the caller's opinion.
func (r *CommentsService) MarkAsSpam(id []string) *CommentsMarkAsSpamCall {
	c := &CommentsMarkAsSpamCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsMarkAsSpamCall) Fields(s ...googleapi.Field) *CommentsMarkAsSpamCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsMarkAsSpamCall) Context(ctx context.Context) *CommentsMarkAsSpamCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsMarkAsSpamCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsMarkAsSpamCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments/markAsSpam")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.markAsSpam", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.markAsSpam" call.
func (c *CommentsMarkAsSpamCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.markAsSpam", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type CommentsSetModerationStatusCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// SetModerationStatus: Sets the moderation status of one or more comments.
//
//   - id: Modifies the moderation status of the comments with the given IDs.
//   - moderationStatus: Specifies the requested moderation status. Note,
//     comments can be in statuses, which are not available through this call.
//     For example, this call does not allow to mark a comment as 'likely spam'.
//     Valid values: 'heldForReview', 'published' or 'rejected'.
func (r *CommentsService) SetModerationStatus(id []string, moderationStatus string) *CommentsSetModerationStatusCall {
	c := &CommentsSetModerationStatusCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	c.urlParams_.Set("moderationStatus", moderationStatus)
	return c
}

// BanAuthor sets the optional parameter "banAuthor": If set to true the author
// of the comment gets added to the ban list. This means all future comments of
// the author will autmomatically be rejected. Only valid in combination with
// STATUS_REJECTED.
func (c *CommentsSetModerationStatusCall) BanAuthor(banAuthor bool) *CommentsSetModerationStatusCall {
	c.urlParams_.Set("banAuthor", fmt.Sprint(banAuthor))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsSetModerationStatusCall) Fields(s ...googleapi.Field) *CommentsSetModerationStatusCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsSetModerationStatusCall) Context(ctx context.Context) *CommentsSetModerationStatusCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsSetModerationStatusCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsSetModerationStatusCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments/setModerationStatus")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.setModerationStatus", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.setModerationStatus" call.
func (c *CommentsSetModerationStatusCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.setModerationStatus", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type CommentsUpdateCall struct {
	s          *Service
	comment    *Comment
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter identifies the properties that the API response
//     will include. You must at least include the snippet part in the parameter
//     value since that part contains all of the properties that the API request
//     can update.
func (r *CommentsService) Update(part []string, comment *Comment) *CommentsUpdateCall {
	c := &CommentsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.comment = comment
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *CommentsUpdateCall) Fields(s ...googleapi.Field) *CommentsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *CommentsUpdateCall) Context(ctx context.Context) *CommentsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *CommentsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *CommentsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.comment)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/comments")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.comments.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.comments.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *Comment.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 (c *CommentsUpdateCall) Do(opts ...googleapi.CallOption) (*Comment, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Comment{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.comments.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type I18nLanguagesListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the i18nLanguage resource properties
//     that the API response will include. Set the parameter value to snippet.
func (r *I18nLanguagesService) List(part []string) *I18nLanguagesListCall {
	c := &I18nLanguagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl":
func (c *I18nLanguagesListCall) Hl(hl string) *I18nLanguagesListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *I18nLanguagesListCall) Fields(s ...googleapi.Field) *I18nLanguagesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *I18nLanguagesListCall) IfNoneMatch(entityTag string) *I18nLanguagesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *I18nLanguagesListCall) Context(ctx context.Context) *I18nLanguagesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *I18nLanguagesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *I18nLanguagesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/i18nLanguages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.i18nLanguages.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.i18nLanguages.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *I18nLanguageListResponse.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 (c *I18nLanguagesListCall) Do(opts ...googleapi.CallOption) (*I18nLanguageListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &I18nLanguageListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.i18nLanguages.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type I18nRegionsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the i18nRegion resource properties
//     that the API response will include. Set the parameter value to snippet.
func (r *I18nRegionsService) List(part []string) *I18nRegionsListCall {
	c := &I18nRegionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl":
func (c *I18nRegionsListCall) Hl(hl string) *I18nRegionsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *I18nRegionsListCall) Fields(s ...googleapi.Field) *I18nRegionsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *I18nRegionsListCall) IfNoneMatch(entityTag string) *I18nRegionsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *I18nRegionsListCall) Context(ctx context.Context) *I18nRegionsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *I18nRegionsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *I18nRegionsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/i18nRegions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.i18nRegions.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.i18nRegions.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *I18nRegionListResponse.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 (c *I18nRegionsListCall) Do(opts ...googleapi.CallOption) (*I18nRegionListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &I18nRegionListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.i18nRegions.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveBroadcastsBindCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Bind: Bind a broadcast to a stream.
//
//   - id: Broadcast to bind to the stream.
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     liveBroadcast resource properties that the API response will include. The
//     part names that you can include in the parameter value are id, snippet,
//     contentDetails, and status.
func (r *LiveBroadcastsService) Bind(id string, part []string) *LiveBroadcastsBindCall {
	c := &LiveBroadcastsBindCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// 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 (c *LiveBroadcastsBindCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsBindCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsBindCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsBindCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// StreamId sets the optional parameter "streamId": Stream to bind, if not set
// unbind the current one.
func (c *LiveBroadcastsBindCall) StreamId(streamId string) *LiveBroadcastsBindCall {
	c.urlParams_.Set("streamId", streamId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsBindCall) Fields(s ...googleapi.Field) *LiveBroadcastsBindCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsBindCall) Context(ctx context.Context) *LiveBroadcastsBindCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsBindCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsBindCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts/bind")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.bind", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.bind" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveBroadcast.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 (c *LiveBroadcastsBindCall) Do(opts ...googleapi.CallOption) (*LiveBroadcast, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveBroadcast{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.bind", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveBroadcastsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Delete a given broadcast.
//
// - id: Broadcast to delete.
func (r *LiveBroadcastsService) Delete(id string) *LiveBroadcastsDeleteCall {
	c := &LiveBroadcastsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *LiveBroadcastsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsDeleteCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsDeleteCall) Fields(s ...googleapi.Field) *LiveBroadcastsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsDeleteCall) Context(ctx context.Context) *LiveBroadcastsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.delete" call.
func (c *LiveBroadcastsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type LiveBroadcastsInsertCall struct {
	s             *Service
	livebroadcast *LiveBroadcast
	urlParams_    gensupport.URLParams
	ctx_          context.Context
	header_       http.Header
}

// Insert: Inserts a new stream for the authenticated user.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part properties that
//     you can include in the parameter value are id, snippet, contentDetails,
//     and status.
func (r *LiveBroadcastsService) Insert(part []string, livebroadcast *LiveBroadcast) *LiveBroadcastsInsertCall {
	c := &LiveBroadcastsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livebroadcast = livebroadcast
	return c
}

// 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 (c *LiveBroadcastsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsInsertCall) Fields(s ...googleapi.Field) *LiveBroadcastsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsInsertCall) Context(ctx context.Context) *LiveBroadcastsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livebroadcast)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveBroadcast.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 (c *LiveBroadcastsInsertCall) Do(opts ...googleapi.CallOption) (*LiveBroadcast, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveBroadcast{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveBroadcastsInsertCuepointCall struct {
	s          *Service
	cuepoint   *Cuepoint
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// InsertCuepoint: Insert cuepoints in a broadcast
func (r *LiveBroadcastsService) InsertCuepoint(cuepoint *Cuepoint) *LiveBroadcastsInsertCuepointCall {
	c := &LiveBroadcastsInsertCuepointCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.cuepoint = cuepoint
	return c
}

// Id sets the optional parameter "id": Broadcast to insert ads to, or
// equivalently `external_video_id` for internal use.
func (c *LiveBroadcastsInsertCuepointCall) Id(id string) *LiveBroadcastsInsertCuepointCall {
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *LiveBroadcastsInsertCuepointCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsInsertCuepointCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsInsertCuepointCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsInsertCuepointCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Part sets the optional parameter "part": The *part* parameter specifies a
// comma-separated list of one or more liveBroadcast resource properties that
// the API response will include. The part names that you can include in the
// parameter value are id, snippet, contentDetails, and status.
func (c *LiveBroadcastsInsertCuepointCall) Part(part ...string) *LiveBroadcastsInsertCuepointCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsInsertCuepointCall) Fields(s ...googleapi.Field) *LiveBroadcastsInsertCuepointCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsInsertCuepointCall) Context(ctx context.Context) *LiveBroadcastsInsertCuepointCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsInsertCuepointCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsInsertCuepointCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.cuepoint)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts/cuepoint")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.insertCuepoint", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.insertCuepoint" call.
// Any non-2xx status code is an error. Response headers are in either
// *Cuepoint.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 (c *LiveBroadcastsInsertCuepointCall) Do(opts ...googleapi.CallOption) (*Cuepoint, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Cuepoint{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.insertCuepoint", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveBroadcastsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieve the list of broadcasts associated with the given channel.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     liveBroadcast resource properties that the API response will include. The
//     part names that you can include in the parameter value are id, snippet,
//     contentDetails, status and statistics.
func (r *LiveBroadcastsService) List(part []string) *LiveBroadcastsListCall {
	c := &LiveBroadcastsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// BroadcastStatus sets the optional parameter "broadcastStatus": Return
// broadcasts with a certain status, e.g. active broadcasts.
//
// Possible values:
//
//	"broadcastStatusFilterUnspecified"
//	"all" - Return all broadcasts.
//	"active" - Return current live broadcasts.
//	"upcoming" - Return broadcasts that have not yet started.
//	"completed" - Return broadcasts that have already ended.
func (c *LiveBroadcastsListCall) BroadcastStatus(broadcastStatus string) *LiveBroadcastsListCall {
	c.urlParams_.Set("broadcastStatus", broadcastStatus)
	return c
}

// BroadcastType sets the optional parameter "broadcastType": Return only
// broadcasts with the selected type.
//
// Possible values:
//
//	"broadcastTypeFilterUnspecified"
//	"all" - Return all broadcasts.
//	"event" (default) - Return only scheduled event broadcasts.
//	"persistent" - Return only persistent broadcasts.
func (c *LiveBroadcastsListCall) BroadcastType(broadcastType string) *LiveBroadcastsListCall {
	c.urlParams_.Set("broadcastType", broadcastType)
	return c
}

// Id sets the optional parameter "id": Return broadcasts with the given ids
// from Stubby or Apiary.
func (c *LiveBroadcastsListCall) Id(id ...string) *LiveBroadcastsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *LiveBroadcastsListCall) MaxResults(maxResults int64) *LiveBroadcastsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine":
func (c *LiveBroadcastsListCall) Mine(mine bool) *LiveBroadcastsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// 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 (c *LiveBroadcastsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsListCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// 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 (c *LiveBroadcastsListCall) PageToken(pageToken string) *LiveBroadcastsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsListCall) Fields(s ...googleapi.Field) *LiveBroadcastsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *LiveBroadcastsListCall) IfNoneMatch(entityTag string) *LiveBroadcastsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsListCall) Context(ctx context.Context) *LiveBroadcastsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveBroadcastListResponse.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 (c *LiveBroadcastsListCall) Do(opts ...googleapi.CallOption) (*LiveBroadcastListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveBroadcastListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *LiveBroadcastsListCall) Pages(ctx context.Context, f func(*LiveBroadcastListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type LiveBroadcastsTransitionCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Transition: Transition a broadcast to a given status.
//
//   - broadcastStatus: The status to which the broadcast is going to transition.
//   - id: Broadcast to transition.
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     liveBroadcast resource properties that the API response will include. The
//     part names that you can include in the parameter value are id, snippet,
//     contentDetails, and status.
func (r *LiveBroadcastsService) Transition(broadcastStatus string, id string, part []string) *LiveBroadcastsTransitionCall {
	c := &LiveBroadcastsTransitionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("broadcastStatus", broadcastStatus)
	c.urlParams_.Set("id", id)
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// 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 (c *LiveBroadcastsTransitionCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsTransitionCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsTransitionCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsTransitionCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsTransitionCall) Fields(s ...googleapi.Field) *LiveBroadcastsTransitionCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsTransitionCall) Context(ctx context.Context) *LiveBroadcastsTransitionCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsTransitionCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsTransitionCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts/transition")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.transition", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.transition" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveBroadcast.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 (c *LiveBroadcastsTransitionCall) Do(opts ...googleapi.CallOption) (*LiveBroadcast, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveBroadcast{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.transition", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveBroadcastsUpdateCall struct {
	s             *Service
	livebroadcast *LiveBroadcast
	urlParams_    gensupport.URLParams
	ctx_          context.Context
	header_       http.Header
}

// Update: Updates an existing broadcast for the authenticated user.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part properties that
//     you can include in the parameter value are id, snippet, contentDetails,
//     and status. Note that this method will override the existing values for
//     all of the mutable properties that are contained in any parts that the
//     parameter value specifies. For example, a broadcast's privacy status is
//     defined in the status part. As such, if your request is updating a private
//     or unlisted broadcast, and the request's part parameter value includes the
//     status part, the broadcast's privacy setting will be updated to whatever
//     value the request body specifies. If the request body does not specify a
//     value, the existing privacy setting will be removed and the broadcast will
//     revert to the default privacy setting.
func (r *LiveBroadcastsService) Update(part []string, livebroadcast *LiveBroadcast) *LiveBroadcastsUpdateCall {
	c := &LiveBroadcastsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livebroadcast = livebroadcast
	return c
}

// 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 (c *LiveBroadcastsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveBroadcastsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveBroadcastsUpdateCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveBroadcastsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveBroadcastsUpdateCall) Fields(s ...googleapi.Field) *LiveBroadcastsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveBroadcastsUpdateCall) Context(ctx context.Context) *LiveBroadcastsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveBroadcastsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveBroadcastsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livebroadcast)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveBroadcasts")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveBroadcasts.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveBroadcast.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 (c *LiveBroadcastsUpdateCall) Do(opts ...googleapi.CallOption) (*LiveBroadcast, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveBroadcast{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveBroadcasts.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveChatBansDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a chat ban.
//
// - id: .
func (r *LiveChatBansService) Delete(id string) *LiveChatBansDeleteCall {
	c := &LiveChatBansDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatBansDeleteCall) Fields(s ...googleapi.Field) *LiveChatBansDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatBansDeleteCall) Context(ctx context.Context) *LiveChatBansDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatBansDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatBansDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/bans")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatBans.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatBans.delete" call.
func (c *LiveChatBansDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatBans.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type LiveChatBansInsertCall struct {
	s           *Service
	livechatban *LiveChatBan
	urlParams_  gensupport.URLParams
	ctx_        context.Context
	header_     http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response returns. Set the parameter value to
//     snippet.
func (r *LiveChatBansService) Insert(part []string, livechatban *LiveChatBan) *LiveChatBansInsertCall {
	c := &LiveChatBansInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livechatban = livechatban
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatBansInsertCall) Fields(s ...googleapi.Field) *LiveChatBansInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatBansInsertCall) Context(ctx context.Context) *LiveChatBansInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatBansInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatBansInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livechatban)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/bans")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatBans.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatBans.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatBan.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 (c *LiveChatBansInsertCall) Do(opts ...googleapi.CallOption) (*LiveChatBan, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatBan{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatBans.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveChatMessagesDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a chat message. A call to this method has a quota cost of 20
// units.
//
// - id: .
func (r *LiveChatMessagesService) Delete(id string) *LiveChatMessagesDeleteCall {
	c := &LiveChatMessagesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatMessagesDeleteCall) Fields(s ...googleapi.Field) *LiveChatMessagesDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatMessagesDeleteCall) Context(ctx context.Context) *LiveChatMessagesDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatMessagesDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatMessagesDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/messages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatMessages.delete" call.
func (c *LiveChatMessagesDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type LiveChatMessagesInsertCall struct {
	s               *Service
	livechatmessage *LiveChatMessage
	urlParams_      gensupport.URLParams
	ctx_            context.Context
	header_         http.Header
}

// Insert: Inserts a new resource into this collection. A call to this method
// has a quota cost of 20 units.
//
//   - part: The `part` parameter serves two purposes. It identifies the
//     properties that the write operation sets as well as the properties that
//     the API response includes. Set the parameter value to `snippet`.
func (r *LiveChatMessagesService) Insert(part []string, livechatmessage *LiveChatMessage) *LiveChatMessagesInsertCall {
	c := &LiveChatMessagesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livechatmessage = livechatmessage
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatMessagesInsertCall) Fields(s ...googleapi.Field) *LiveChatMessagesInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatMessagesInsertCall) Context(ctx context.Context) *LiveChatMessagesInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatMessagesInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatMessagesInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livechatmessage)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/messages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatMessages.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatMessage.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 (c *LiveChatMessagesInsertCall) Do(opts ...googleapi.CallOption) (*LiveChatMessage, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatMessage{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveChatMessagesListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered. A call to this
// method has a quota cost of 5 units.
//
//   - liveChatId: The ID of the live chat for which messages should be returned.
//   - part: The `part` parameter specifies the `liveChatMessage` resource parts
//     that the API response includes. Supported values are `id`, `snippet`, and
//     `authorDetails`.
func (r *LiveChatMessagesService) List(liveChatId string, part []string) *LiveChatMessagesListCall {
	c := &LiveChatMessagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("liveChatId", liveChatId)
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl": Specifies the localization language in
// which the system messages should be returned.
func (c *LiveChatMessagesListCall) Hl(hl string) *LiveChatMessagesListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// MaxResults sets the optional parameter "maxResults": The `maxResults`
// parameter specifies the maximum number of items that should be returned in
// the result set. Not used in the streaming RPC.
func (c *LiveChatMessagesListCall) MaxResults(maxResults int64) *LiveChatMessagesListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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` property identifies other pages that could
// be retrieved.
func (c *LiveChatMessagesListCall) PageToken(pageToken string) *LiveChatMessagesListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// ProfileImageSize sets the optional parameter "profileImageSize": Specifies
// the size of the profile image that should be returned for each user.
func (c *LiveChatMessagesListCall) ProfileImageSize(profileImageSize int64) *LiveChatMessagesListCall {
	c.urlParams_.Set("profileImageSize", fmt.Sprint(profileImageSize))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatMessagesListCall) Fields(s ...googleapi.Field) *LiveChatMessagesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *LiveChatMessagesListCall) IfNoneMatch(entityTag string) *LiveChatMessagesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatMessagesListCall) Context(ctx context.Context) *LiveChatMessagesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatMessagesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatMessagesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/messages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatMessages.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatMessageListResponse.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 (c *LiveChatMessagesListCall) Do(opts ...googleapi.CallOption) (*LiveChatMessageListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatMessageListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *LiveChatMessagesListCall) Pages(ctx context.Context, f func(*LiveChatMessageListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type LiveChatMessagesTransitionCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Transition: Transitions a durable chat event. A call to this method has a
// quota cost of 20 units.
func (r *LiveChatMessagesService) Transition() *LiveChatMessagesTransitionCall {
	c := &LiveChatMessagesTransitionCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// Id sets the optional parameter "id": The ID that uniquely identifies the
// chat message event to transition.
func (c *LiveChatMessagesTransitionCall) Id(id string) *LiveChatMessagesTransitionCall {
	c.urlParams_.Set("id", id)
	return c
}

// Status sets the optional parameter "status": The status to which the chat
// event is going to transition.
//
// Possible values:
//
//	"statusUnspecified" - Default unknown enum value.
//	"closed" - The durable chat event is over.
func (c *LiveChatMessagesTransitionCall) Status(status string) *LiveChatMessagesTransitionCall {
	c.urlParams_.Set("status", status)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatMessagesTransitionCall) Fields(s ...googleapi.Field) *LiveChatMessagesTransitionCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatMessagesTransitionCall) Context(ctx context.Context) *LiveChatMessagesTransitionCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatMessagesTransitionCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatMessagesTransitionCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/messages/transition")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.transition", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatMessages.transition" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatMessage.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 (c *LiveChatMessagesTransitionCall) Do(opts ...googleapi.CallOption) (*LiveChatMessage, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatMessage{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatMessages.transition", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveChatModeratorsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a chat moderator.
//
// - id: .
func (r *LiveChatModeratorsService) Delete(id string) *LiveChatModeratorsDeleteCall {
	c := &LiveChatModeratorsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatModeratorsDeleteCall) Fields(s ...googleapi.Field) *LiveChatModeratorsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatModeratorsDeleteCall) Context(ctx context.Context) *LiveChatModeratorsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatModeratorsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatModeratorsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/moderators")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatModerators.delete" call.
func (c *LiveChatModeratorsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type LiveChatModeratorsInsertCall struct {
	s                 *Service
	livechatmoderator *LiveChatModerator
	urlParams_        gensupport.URLParams
	ctx_              context.Context
	header_           http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response returns. Set the parameter value to
//     snippet.
func (r *LiveChatModeratorsService) Insert(part []string, livechatmoderator *LiveChatModerator) *LiveChatModeratorsInsertCall {
	c := &LiveChatModeratorsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livechatmoderator = livechatmoderator
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatModeratorsInsertCall) Fields(s ...googleapi.Field) *LiveChatModeratorsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatModeratorsInsertCall) Context(ctx context.Context) *LiveChatModeratorsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatModeratorsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatModeratorsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livechatmoderator)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/moderators")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatModerators.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatModerator.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 (c *LiveChatModeratorsInsertCall) Do(opts ...googleapi.CallOption) (*LiveChatModerator, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatModerator{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveChatModeratorsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - liveChatId: The id of the live chat for which moderators should be
//     returned.
//   - part: The *part* parameter specifies the liveChatModerator resource parts
//     that the API response will include. Supported values are id and snippet.
func (r *LiveChatModeratorsService) List(liveChatId string, part []string) *LiveChatModeratorsListCall {
	c := &LiveChatModeratorsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("liveChatId", liveChatId)
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *LiveChatModeratorsListCall) MaxResults(maxResults int64) *LiveChatModeratorsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *LiveChatModeratorsListCall) PageToken(pageToken string) *LiveChatModeratorsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveChatModeratorsListCall) Fields(s ...googleapi.Field) *LiveChatModeratorsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *LiveChatModeratorsListCall) IfNoneMatch(entityTag string) *LiveChatModeratorsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveChatModeratorsListCall) Context(ctx context.Context) *LiveChatModeratorsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveChatModeratorsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveChatModeratorsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/moderators")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveChatModerators.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatModeratorListResponse.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 (c *LiveChatModeratorsListCall) Do(opts ...googleapi.CallOption) (*LiveChatModeratorListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatModeratorListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveChatModerators.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *LiveChatModeratorsListCall) Pages(ctx context.Context, f func(*LiveChatModeratorListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type LiveStreamsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes an existing stream for the authenticated user.
//
// - id: .
func (r *LiveStreamsService) Delete(id string) *LiveStreamsDeleteCall {
	c := &LiveStreamsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *LiveStreamsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveStreamsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveStreamsDeleteCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveStreamsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveStreamsDeleteCall) Fields(s ...googleapi.Field) *LiveStreamsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveStreamsDeleteCall) Context(ctx context.Context) *LiveStreamsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveStreamsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveStreamsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveStreams")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveStreams.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveStreams.delete" call.
func (c *LiveStreamsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveStreams.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type LiveStreamsInsertCall struct {
	s          *Service
	livestream *LiveStream
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Insert: Inserts a new stream for the authenticated user.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part properties that
//     you can include in the parameter value are id, snippet, cdn,
//     content_details, and status.
func (r *LiveStreamsService) Insert(part []string, livestream *LiveStream) *LiveStreamsInsertCall {
	c := &LiveStreamsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livestream = livestream
	return c
}

// 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 (c *LiveStreamsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveStreamsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveStreamsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveStreamsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveStreamsInsertCall) Fields(s ...googleapi.Field) *LiveStreamsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveStreamsInsertCall) Context(ctx context.Context) *LiveStreamsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveStreamsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveStreamsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livestream)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveStreams")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveStreams.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveStreams.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveStream.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 (c *LiveStreamsInsertCall) Do(opts ...googleapi.CallOption) (*LiveStream, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveStream{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveStreams.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type LiveStreamsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieve the list of streams associated with the given channel. --
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     liveStream resource properties that the API response will include. The
//     part names that you can include in the parameter value are id, snippet,
//     cdn, and status.
func (r *LiveStreamsService) List(part []string) *LiveStreamsListCall {
	c := &LiveStreamsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Id sets the optional parameter "id": Return LiveStreams with the given ids
// from Stubby or Apiary.
func (c *LiveStreamsListCall) Id(id ...string) *LiveStreamsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *LiveStreamsListCall) MaxResults(maxResults int64) *LiveStreamsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine":
func (c *LiveStreamsListCall) Mine(mine bool) *LiveStreamsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// 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 (c *LiveStreamsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveStreamsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveStreamsListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveStreamsListCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// 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 (c *LiveStreamsListCall) PageToken(pageToken string) *LiveStreamsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveStreamsListCall) Fields(s ...googleapi.Field) *LiveStreamsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *LiveStreamsListCall) IfNoneMatch(entityTag string) *LiveStreamsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveStreamsListCall) Context(ctx context.Context) *LiveStreamsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveStreamsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveStreamsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveStreams")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveStreams.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveStreams.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveStreamListResponse.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 (c *LiveStreamsListCall) Do(opts ...googleapi.CallOption) (*LiveStreamListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveStreamListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveStreams.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *LiveStreamsListCall) Pages(ctx context.Context, f func(*LiveStreamListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type LiveStreamsUpdateCall struct {
	s          *Service
	livestream *LiveStream
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing stream for the authenticated user.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. The part properties that
//     you can include in the parameter value are id, snippet, cdn, and status.
//     Note that this method will override the existing values for all of the
//     mutable properties that are contained in any parts that the parameter
//     value specifies. If the request body does not specify a value for a
//     mutable property, the existing value for that property will be removed.
func (r *LiveStreamsService) Update(part []string, livestream *LiveStream) *LiveStreamsUpdateCall {
	c := &LiveStreamsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.livestream = livestream
	return c
}

// 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 (c *LiveStreamsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *LiveStreamsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *LiveStreamsUpdateCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *LiveStreamsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *LiveStreamsUpdateCall) Fields(s ...googleapi.Field) *LiveStreamsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *LiveStreamsUpdateCall) Context(ctx context.Context) *LiveStreamsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *LiveStreamsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *LiveStreamsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.livestream)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveStreams")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.liveStreams.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.liveStreams.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveStream.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 (c *LiveStreamsUpdateCall) Do(opts ...googleapi.CallOption) (*LiveStream, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveStream{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.liveStreams.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type MembersListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of members that match the request criteria for a
// channel.
//
//   - part: The *part* parameter specifies the member resource parts that the
//     API response will include. Set the parameter value to snippet.
func (r *MembersService) List(part []string) *MembersListCall {
	c := &MembersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// FilterByMemberChannelId sets the optional parameter
// "filterByMemberChannelId": Comma separated list of channel IDs. Only data
// about members that are part of this list will be included in the response.
func (c *MembersListCall) FilterByMemberChannelId(filterByMemberChannelId string) *MembersListCall {
	c.urlParams_.Set("filterByMemberChannelId", filterByMemberChannelId)
	return c
}

// HasAccessToLevel sets the optional parameter "hasAccessToLevel": Filter
// members in the results set to the ones that have access to a level.
func (c *MembersListCall) HasAccessToLevel(hasAccessToLevel string) *MembersListCall {
	c.urlParams_.Set("hasAccessToLevel", hasAccessToLevel)
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *MembersListCall) MaxResults(maxResults int64) *MembersListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mode sets the optional parameter "mode": Parameter that specifies which
// channel members to return.
//
// Possible values:
//
//	"listMembersModeUnknown"
//	"updates" - Return only members that joined after the first call with this
//
// mode was made.
//
//	"all_current" (default) - Return all current members, from newest to
//
// oldest.
func (c *MembersListCall) Mode(mode string) *MembersListCall {
	c.urlParams_.Set("mode", mode)
	return c
}

// 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 (c *MembersListCall) PageToken(pageToken string) *MembersListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *MembersListCall) Fields(s ...googleapi.Field) *MembersListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *MembersListCall) IfNoneMatch(entityTag string) *MembersListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *MembersListCall) Context(ctx context.Context) *MembersListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *MembersListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *MembersListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/members")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.members.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.members.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *MemberListResponse.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 (c *MembersListCall) Do(opts ...googleapi.CallOption) (*MemberListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &MemberListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.members.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *MembersListCall) Pages(ctx context.Context, f func(*MemberListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type MembershipsLevelsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of all pricing levels offered by a creator to the
// fans.
//
//   - part: The *part* parameter specifies the membershipsLevel resource parts
//     that the API response will include. Supported values are id and snippet.
func (r *MembershipsLevelsService) List(part []string) *MembershipsLevelsListCall {
	c := &MembershipsLevelsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *MembershipsLevelsListCall) Fields(s ...googleapi.Field) *MembershipsLevelsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *MembershipsLevelsListCall) IfNoneMatch(entityTag string) *MembershipsLevelsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *MembershipsLevelsListCall) Context(ctx context.Context) *MembershipsLevelsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *MembershipsLevelsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *MembershipsLevelsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/membershipsLevels")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.membershipsLevels.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.membershipsLevels.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *MembershipsLevelListResponse.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 (c *MembershipsLevelsListCall) Do(opts ...googleapi.CallOption) (*MembershipsLevelListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &MembershipsLevelListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.membershipsLevels.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistImagesDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
func (r *PlaylistImagesService) Delete() *PlaylistImagesDeleteCall {
	c := &PlaylistImagesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// Id sets the optional parameter "id": Id to identify this image. This is
// returned from by the List method.
func (c *PlaylistImagesDeleteCall) Id(id string) *PlaylistImagesDeleteCall {
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *PlaylistImagesDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistImagesDeleteCall) Fields(s ...googleapi.Field) *PlaylistImagesDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistImagesDeleteCall) Context(ctx context.Context) *PlaylistImagesDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistImagesDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistImagesDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistImages.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistImages.delete" call.
func (c *PlaylistImagesDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistImages.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type PlaylistImagesInsertCall struct {
	s             *Service
	playlistimage *PlaylistImage
	urlParams_    gensupport.URLParams
	mediaInfo_    *gensupport.MediaInfo
	ctx_          context.Context
	header_       http.Header
}

// Insert: Inserts a new resource into this collection.
func (r *PlaylistImagesService) Insert(playlistimage *PlaylistImage) *PlaylistImagesInsertCall {
	c := &PlaylistImagesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.playlistimage = playlistimage
	return c
}

// 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 (c *PlaylistImagesInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *PlaylistImagesInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistImagesInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Part sets the optional parameter "part": The *part* parameter specifies the
// properties that the API response will include.
func (c *PlaylistImagesInsertCall) Part(part ...string) *PlaylistImagesInsertCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// 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 (c *PlaylistImagesInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *PlaylistImagesInsertCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *PlaylistImagesInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *PlaylistImagesInsertCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *PlaylistImagesInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *PlaylistImagesInsertCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistImagesInsertCall) Fields(s ...googleapi.Field) *PlaylistImagesInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *PlaylistImagesInsertCall) Context(ctx context.Context) *PlaylistImagesInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistImagesInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistImagesInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlistimage)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/playlistImages")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistImages.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistImages.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistImage.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 (c *PlaylistImagesInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistImage, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &PlaylistImage{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistImages.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistImagesListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
func (r *PlaylistImagesService) List() *PlaylistImagesListCall {
	c := &PlaylistImagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *PlaylistImagesListCall) MaxResults(maxResults int64) *PlaylistImagesListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *PlaylistImagesListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *PlaylistImagesListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistImagesListCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// 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 (c *PlaylistImagesListCall) PageToken(pageToken string) *PlaylistImagesListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Parent sets the optional parameter "parent": Return PlaylistImages for this
// playlist id.
func (c *PlaylistImagesListCall) Parent(parent string) *PlaylistImagesListCall {
	c.urlParams_.Set("parent", parent)
	return c
}

// Part sets the optional parameter "part": The *part* parameter specifies a
// comma-separated list of one or more playlistImage resource properties that
// the API response will include. If the parameter identifies a property that
// contains child properties, the child properties will be included in the
// response.
func (c *PlaylistImagesListCall) Part(part ...string) *PlaylistImagesListCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistImagesListCall) Fields(s ...googleapi.Field) *PlaylistImagesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *PlaylistImagesListCall) IfNoneMatch(entityTag string) *PlaylistImagesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistImagesListCall) Context(ctx context.Context) *PlaylistImagesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistImagesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistImagesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistImages.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistImages.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistImageListResponse.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 (c *PlaylistImagesListCall) Do(opts ...googleapi.CallOption) (*PlaylistImageListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PlaylistImageListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistImages.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *PlaylistImagesListCall) Pages(ctx context.Context, f func(*PlaylistImageListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type PlaylistImagesUpdateCall struct {
	s             *Service
	playlistimage *PlaylistImage
	urlParams_    gensupport.URLParams
	mediaInfo_    *gensupport.MediaInfo
	ctx_          context.Context
	header_       http.Header
}

// Update: Updates an existing resource.
func (r *PlaylistImagesService) Update(playlistimage *PlaylistImage) *PlaylistImagesUpdateCall {
	c := &PlaylistImagesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.playlistimage = playlistimage
	return c
}

// 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 (c *PlaylistImagesUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Part sets the optional parameter "part": The *part* parameter specifies the
// properties that the API response will include.
func (c *PlaylistImagesUpdateCall) Part(part ...string) *PlaylistImagesUpdateCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// 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 (c *PlaylistImagesUpdateCall) Media(r io.Reader, options ...googleapi.MediaOption) *PlaylistImagesUpdateCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *PlaylistImagesUpdateCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *PlaylistImagesUpdateCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *PlaylistImagesUpdateCall) ProgressUpdater(pu googleapi.ProgressUpdater) *PlaylistImagesUpdateCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistImagesUpdateCall) Fields(s ...googleapi.Field) *PlaylistImagesUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *PlaylistImagesUpdateCall) Context(ctx context.Context) *PlaylistImagesUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistImagesUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistImagesUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlistimage)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/playlistImages")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistImages.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistImages.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistImage.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 (c *PlaylistImagesUpdateCall) Do(opts ...googleapi.CallOption) (*PlaylistImage, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &PlaylistImage{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistImages.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistItemsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *PlaylistItemsService) Delete(id string) *PlaylistItemsDeleteCall {
	c := &PlaylistItemsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *PlaylistItemsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistItemsDeleteCall) Fields(s ...googleapi.Field) *PlaylistItemsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistItemsDeleteCall) Context(ctx context.Context) *PlaylistItemsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistItemsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistItemsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistItems.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistItems.delete" call.
func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistItems.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type PlaylistItemsInsertCall struct {
	s            *Service
	playlistitem *PlaylistItem
	urlParams_   gensupport.URLParams
	ctx_         context.Context
	header_      http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include.
func (r *PlaylistItemsService) Insert(part []string, playlistitem *PlaylistItem) *PlaylistItemsInsertCall {
	c := &PlaylistItemsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.playlistitem = playlistitem
	return c
}

// 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 (c *PlaylistItemsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistItemsInsertCall) Fields(s ...googleapi.Field) *PlaylistItemsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistItemsInsertCall) Context(ctx context.Context) *PlaylistItemsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistItemsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistItemsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlistitem)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistItems.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistItems.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistItem.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 (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistItem, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PlaylistItem{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistItems.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistItemsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     playlistItem resource properties that the API response will include. If
//     the parameter identifies a property that contains child properties, the
//     child properties will be included in the response. For example, in a
//     playlistItem resource, the snippet property contains numerous fields,
//     including the title, description, position, and resourceId properties. As
//     such, if you set *part=snippet*, the API response will contain all of
//     those properties.
func (r *PlaylistItemsService) List(part []string) *PlaylistItemsListCall {
	c := &PlaylistItemsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Id sets the optional parameter "id":
func (c *PlaylistItemsListCall) Id(id ...string) *PlaylistItemsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *PlaylistItemsListCall) MaxResults(maxResults int64) *PlaylistItemsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *PlaylistItemsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// 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 (c *PlaylistItemsListCall) PageToken(pageToken string) *PlaylistItemsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// PlaylistId sets the optional parameter "playlistId": Return the playlist
// items within the given playlist.
func (c *PlaylistItemsListCall) PlaylistId(playlistId string) *PlaylistItemsListCall {
	c.urlParams_.Set("playlistId", playlistId)
	return c
}

// VideoId sets the optional parameter "videoId": Return the playlist items
// associated with the given video ID.
func (c *PlaylistItemsListCall) VideoId(videoId string) *PlaylistItemsListCall {
	c.urlParams_.Set("videoId", videoId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistItemsListCall) Fields(s ...googleapi.Field) *PlaylistItemsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *PlaylistItemsListCall) IfNoneMatch(entityTag string) *PlaylistItemsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistItemsListCall) Context(ctx context.Context) *PlaylistItemsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistItemsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistItemsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistItems.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistItems.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistItemListResponse.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 (c *PlaylistItemsListCall) Do(opts ...googleapi.CallOption) (*PlaylistItemListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PlaylistItemListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistItems.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *PlaylistItemsListCall) Pages(ctx context.Context, f func(*PlaylistItemListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type PlaylistItemsUpdateCall struct {
	s            *Service
	playlistitem *PlaylistItem
	urlParams_   gensupport.URLParams
	ctx_         context.Context
	header_      http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. Note that this method will
//     override the existing values for all of the mutable properties that are
//     contained in any parts that the parameter value specifies. For example, a
//     playlist item can specify a start time and end time, which identify the
//     times portion of the video that should play when users watch the video in
//     the playlist. If your request is updating a playlist item that sets these
//     values, and the request's part parameter value includes the contentDetails
//     part, the playlist item's start and end times will be updated to whatever
//     value the request body specifies. If the request body does not specify
//     values, the existing start and end times will be removed and replaced with
//     the default settings.
func (r *PlaylistItemsService) Update(part []string, playlistitem *PlaylistItem) *PlaylistItemsUpdateCall {
	c := &PlaylistItemsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.playlistitem = playlistitem
	return c
}

// 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 (c *PlaylistItemsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistItemsUpdateCall) Fields(s ...googleapi.Field) *PlaylistItemsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistItemsUpdateCall) Context(ctx context.Context) *PlaylistItemsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistItemsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistItemsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlistitem)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlistItems.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlistItems.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistItem.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 (c *PlaylistItemsUpdateCall) Do(opts ...googleapi.CallOption) (*PlaylistItem, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PlaylistItem{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlistItems.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *PlaylistsService) Delete(id string) *PlaylistsDeleteCall {
	c := &PlaylistsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *PlaylistsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistsDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistsDeleteCall) Fields(s ...googleapi.Field) *PlaylistsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistsDeleteCall) Context(ctx context.Context) *PlaylistsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlists")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlists.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlists.delete" call.
func (c *PlaylistsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlists.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type PlaylistsInsertCall struct {
	s          *Service
	playlist   *Playlist
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include.
func (r *PlaylistsService) Insert(part []string, playlist *Playlist) *PlaylistsInsertCall {
	c := &PlaylistsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.playlist = playlist
	return c
}

// 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 (c *PlaylistsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *PlaylistsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistsInsertCall) Fields(s ...googleapi.Field) *PlaylistsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistsInsertCall) Context(ctx context.Context) *PlaylistsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlist)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlists")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlists.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlists.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *Playlist.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 (c *PlaylistsInsertCall) Do(opts ...googleapi.CallOption) (*Playlist, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Playlist{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlists.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type PlaylistsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     playlist resource properties that the API response will include. If the
//     parameter identifies a property that contains child properties, the child
//     properties will be included in the response. For example, in a playlist
//     resource, the snippet property contains properties like author, title,
//     description, tags, and timeCreated. As such, if you set *part=snippet*,
//     the API response will contain all of those properties.
func (r *PlaylistsService) List(part []string) *PlaylistsListCall {
	c := &PlaylistsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ChannelId sets the optional parameter "channelId": Return the playlists
// owned by the specified channel ID.
func (c *PlaylistsListCall) ChannelId(channelId string) *PlaylistsListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// Hl sets the optional parameter "hl": Return content in specified language
func (c *PlaylistsListCall) Hl(hl string) *PlaylistsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Id sets the optional parameter "id": Return the playlists with the given IDs
// for Stubby or Apiary.
func (c *PlaylistsListCall) Id(id ...string) *PlaylistsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *PlaylistsListCall) MaxResults(maxResults int64) *PlaylistsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine": Return the playlists owned by the
// authenticated user.
func (c *PlaylistsListCall) Mine(mine bool) *PlaylistsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// 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 (c *PlaylistsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *PlaylistsListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistsListCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// 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 (c *PlaylistsListCall) PageToken(pageToken string) *PlaylistsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistsListCall) Fields(s ...googleapi.Field) *PlaylistsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *PlaylistsListCall) IfNoneMatch(entityTag string) *PlaylistsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistsListCall) Context(ctx context.Context) *PlaylistsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlists")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlists.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlists.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *PlaylistListResponse.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 (c *PlaylistsListCall) Do(opts ...googleapi.CallOption) (*PlaylistListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &PlaylistListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlists.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *PlaylistsListCall) Pages(ctx context.Context, f func(*PlaylistListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type PlaylistsUpdateCall struct {
	s          *Service
	playlist   *Playlist
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. Note that this method will
//     override the existing values for mutable properties that are contained in
//     any parts that the request body specifies. For example, a playlist's
//     description is contained in the snippet part, which must be included in
//     the request body. If the request does not specify a value for the
//     snippet.description property, the playlist's existing description will be
//     deleted.
func (r *PlaylistsService) Update(part []string, playlist *Playlist) *PlaylistsUpdateCall {
	c := &PlaylistsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.playlist = playlist
	return c
}

// 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 (c *PlaylistsUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistsUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *PlaylistsUpdateCall) Fields(s ...googleapi.Field) *PlaylistsUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *PlaylistsUpdateCall) Context(ctx context.Context) *PlaylistsUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *PlaylistsUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *PlaylistsUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.playlist)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlists")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.playlists.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.playlists.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *Playlist.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 (c *PlaylistsUpdateCall) Do(opts ...googleapi.CallOption) (*Playlist, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Playlist{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.playlists.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type SearchListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of search resources
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     search resource properties that the API response will include. Set the
//     parameter value to snippet.
func (r *SearchService) List(part []string) *SearchListCall {
	c := &SearchListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ChannelId sets the optional parameter "channelId": Filter on resources
// belonging to this channelId. (Force TAP rebuild)
func (c *SearchListCall) ChannelId(channelId string) *SearchListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// ChannelType sets the optional parameter "channelType": Add a filter on the
// channel search.
//
// Possible values:
//
//	"channelTypeUnspecified"
//	"any" - Return all channels.
//	"show" - Only retrieve shows.
func (c *SearchListCall) ChannelType(channelType string) *SearchListCall {
	c.urlParams_.Set("channelType", channelType)
	return c
}

// EventType sets the optional parameter "eventType": Filter on the livestream
// status of the videos.
//
// Possible values:
//
//	"none" - The resource does not have live broadcast content.
//	"upcoming" - The live broadcast is upcoming.
//	"live" - The live broadcast is active.
//	"completed" - The live broadcast has been completed.
func (c *SearchListCall) EventType(eventType string) *SearchListCall {
	c.urlParams_.Set("eventType", eventType)
	return c
}

// ForContentOwner sets the optional parameter "forContentOwner": Search owned
// by a content owner.
func (c *SearchListCall) ForContentOwner(forContentOwner bool) *SearchListCall {
	c.urlParams_.Set("forContentOwner", fmt.Sprint(forContentOwner))
	return c
}

// ForDeveloper sets the optional parameter "forDeveloper": Restrict the search
// to only retrieve videos uploaded using the project id of the authenticated
// user.
func (c *SearchListCall) ForDeveloper(forDeveloper bool) *SearchListCall {
	c.urlParams_.Set("forDeveloper", fmt.Sprint(forDeveloper))
	return c
}

// ForMine sets the optional parameter "forMine": Search for the private videos
// of the authenticated user.
func (c *SearchListCall) ForMine(forMine bool) *SearchListCall {
	c.urlParams_.Set("forMine", fmt.Sprint(forMine))
	return c
}

// Location sets the optional parameter "location": Filter on location of the
// video
func (c *SearchListCall) Location(location string) *SearchListCall {
	c.urlParams_.Set("location", location)
	return c
}

// LocationRadius sets the optional parameter "locationRadius": Filter on
// distance from the location (specified above).
func (c *SearchListCall) LocationRadius(locationRadius string) *SearchListCall {
	c.urlParams_.Set("locationRadius", locationRadius)
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *SearchListCall) MaxResults(maxResults int64) *SearchListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *SearchListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *SearchListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Order sets the optional parameter "order": Sort order of the results.
//
// Possible values:
//
//	"searchSortUnspecified"
//	"date" - Resources are sorted in reverse chronological order based on the
//
// date they were created.
//
//	"rating" - Resources are sorted from highest to lowest rating.
//	"viewCount" - Resources are sorted from highest to lowest number of views.
//	"relevance" (default) - Resources are sorted based on their relevance to
//
// the search query. This is the default value for this parameter.
//
//	"title" - Resources are sorted alphabetically by title.
//	"videoCount" - Channels are sorted in descending order of their number of
//
// uploaded videos.
func (c *SearchListCall) Order(order string) *SearchListCall {
	c.urlParams_.Set("order", order)
	return c
}

// 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 (c *SearchListCall) PageToken(pageToken string) *SearchListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// PublishedAfter sets the optional parameter "publishedAfter": Filter on
// resources published after this date.
func (c *SearchListCall) PublishedAfter(publishedAfter string) *SearchListCall {
	c.urlParams_.Set("publishedAfter", publishedAfter)
	return c
}

// PublishedBefore sets the optional parameter "publishedBefore": Filter on
// resources published before this date.
func (c *SearchListCall) PublishedBefore(publishedBefore string) *SearchListCall {
	c.urlParams_.Set("publishedBefore", publishedBefore)
	return c
}

// Q sets the optional parameter "q": Textual search terms to match.
func (c *SearchListCall) Q(q string) *SearchListCall {
	c.urlParams_.Set("q", q)
	return c
}

// RegionCode sets the optional parameter "regionCode": Display the content as
// seen by viewers in this country.
func (c *SearchListCall) RegionCode(regionCode string) *SearchListCall {
	c.urlParams_.Set("regionCode", regionCode)
	return c
}

// RelevanceLanguage sets the optional parameter "relevanceLanguage": Return
// results relevant to this language.
func (c *SearchListCall) RelevanceLanguage(relevanceLanguage string) *SearchListCall {
	c.urlParams_.Set("relevanceLanguage", relevanceLanguage)
	return c
}

// SafeSearch sets the optional parameter "safeSearch": Indicates whether the
// search results should include restricted content as well as standard
// content.
//
// Possible values:
//
//	"safeSearchSettingUnspecified"
//	"none" - YouTube will not filter the search result set.
//	"moderate" (default) - YouTube will filter some content from search
//
// results and, at the least, will filter content that is restricted in your
// locale. Based on their content, search results could be removed from search
// results or demoted in search results. This is the default parameter value.
//
//	"strict" - YouTube will try to exclude all restricted content from the
//
// search result set. Based on their content, search results could be removed
// from search results or demoted in search results.
func (c *SearchListCall) SafeSearch(safeSearch string) *SearchListCall {
	c.urlParams_.Set("safeSearch", safeSearch)
	return c
}

// TopicId sets the optional parameter "topicId": Restrict results to a
// particular topic.
func (c *SearchListCall) TopicId(topicId string) *SearchListCall {
	c.urlParams_.Set("topicId", topicId)
	return c
}

// Type sets the optional parameter "type": Restrict results to a particular
// set of resource types from One Platform.
func (c *SearchListCall) Type(type_ ...string) *SearchListCall {
	c.urlParams_.SetMulti("type", append([]string{}, type_...))
	return c
}

// VideoCaption sets the optional parameter "videoCaption": Filter on the
// presence of captions on the videos.
//
// Possible values:
//
//	"videoCaptionUnspecified"
//	"any" - Do not filter results based on caption availability.
//	"closedCaption" - Only include videos that have captions.
//	"none" - Only include videos that do not have captions.
func (c *SearchListCall) VideoCaption(videoCaption string) *SearchListCall {
	c.urlParams_.Set("videoCaption", videoCaption)
	return c
}

// VideoCategoryId sets the optional parameter "videoCategoryId": Filter on
// videos in a specific category.
func (c *SearchListCall) VideoCategoryId(videoCategoryId string) *SearchListCall {
	c.urlParams_.Set("videoCategoryId", videoCategoryId)
	return c
}

// VideoDefinition sets the optional parameter "videoDefinition": Filter on the
// definition of the videos.
//
// Possible values:
//
//	"any" - Return all videos, regardless of their resolution.
//	"standard" - Only retrieve videos in standard definition.
//	"high" - Only retrieve HD videos.
func (c *SearchListCall) VideoDefinition(videoDefinition string) *SearchListCall {
	c.urlParams_.Set("videoDefinition", videoDefinition)
	return c
}

// VideoDimension sets the optional parameter "videoDimension": Filter on 3d
// videos.
//
// Possible values:
//
//	"any" - Include both 3D and non-3D videos in returned results. This is the
//
// default value.
//
//	"2d" - Restrict search results to exclude 3D videos.
//	"3d" - Restrict search results to only include 3D videos.
func (c *SearchListCall) VideoDimension(videoDimension string) *SearchListCall {
	c.urlParams_.Set("videoDimension", videoDimension)
	return c
}

// VideoDuration sets the optional parameter "videoDuration": Filter on the
// duration of the videos.
//
// Possible values:
//
//	"videoDurationUnspecified"
//	"any" - Do not filter video search results based on their duration. This
//
// is the default value.
//
//	"short" - Only include videos that are less than four minutes long.
//	"medium" - Only include videos that are between four and 20 minutes long
//
// (inclusive).
//
//	"long" - Only include videos longer than 20 minutes.
func (c *SearchListCall) VideoDuration(videoDuration string) *SearchListCall {
	c.urlParams_.Set("videoDuration", videoDuration)
	return c
}

// VideoEmbeddable sets the optional parameter "videoEmbeddable": Filter on
// embeddable videos.
//
// Possible values:
//
//	"videoEmbeddableUnspecified"
//	"any" - Return all videos, embeddable or not.
//	"true" - Only retrieve embeddable videos.
func (c *SearchListCall) VideoEmbeddable(videoEmbeddable string) *SearchListCall {
	c.urlParams_.Set("videoEmbeddable", videoEmbeddable)
	return c
}

// VideoLicense sets the optional parameter "videoLicense": Filter on the
// license of the videos.
//
// Possible values:
//
//	"any" - Return all videos, regardless of which license they have, that
//
// match the query parameters.
//
//	"youtube" - Only return videos that have the standard YouTube license.
//	"creativeCommon" - Only return videos that have a Creative Commons
//
// license. Users can reuse videos with this license in other videos that they
// create. Learn more.
func (c *SearchListCall) VideoLicense(videoLicense string) *SearchListCall {
	c.urlParams_.Set("videoLicense", videoLicense)
	return c
}

// VideoPaidProductPlacement sets the optional parameter
// "videoPaidProductPlacement":
//
// Possible values:
//
//	"videoPaidProductPlacementUnspecified"
//	"any" - Return all videos, paid product placement or not.
//	"true" - Restrict results to only videos with paid product placement.
func (c *SearchListCall) VideoPaidProductPlacement(videoPaidProductPlacement string) *SearchListCall {
	c.urlParams_.Set("videoPaidProductPlacement", videoPaidProductPlacement)
	return c
}

// VideoSyndicated sets the optional parameter "videoSyndicated": Filter on
// syndicated videos.
//
// Possible values:
//
//	"videoSyndicatedUnspecified"
//	"any" - Return all videos, syndicated or not.
//	"true" - Only retrieve syndicated videos.
func (c *SearchListCall) VideoSyndicated(videoSyndicated string) *SearchListCall {
	c.urlParams_.Set("videoSyndicated", videoSyndicated)
	return c
}

// VideoType sets the optional parameter "videoType": Filter on videos of a
// specific type.
//
// Possible values:
//
//	"videoTypeUnspecified"
//	"any" - Return all videos.
//	"movie" - Only retrieve movies.
//	"episode" - Only retrieve episodes of shows.
func (c *SearchListCall) VideoType(videoType string) *SearchListCall {
	c.urlParams_.Set("videoType", videoType)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *SearchListCall) Fields(s ...googleapi.Field) *SearchListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *SearchListCall) IfNoneMatch(entityTag string) *SearchListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *SearchListCall) Context(ctx context.Context) *SearchListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *SearchListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *SearchListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/search")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.search.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.search.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *SearchListResponse.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 (c *SearchListCall) Do(opts ...googleapi.CallOption) (*SearchListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &SearchListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.search.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *SearchListCall) Pages(ctx context.Context, f func(*SearchListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type SubscriptionsDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *SubscriptionsService) Delete(id string) *SubscriptionsDeleteCall {
	c := &SubscriptionsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *SubscriptionsDeleteCall) Fields(s ...googleapi.Field) *SubscriptionsDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *SubscriptionsDeleteCall) Context(ctx context.Context) *SubscriptionsDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *SubscriptionsDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *SubscriptionsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/subscriptions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.subscriptions.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.subscriptions.delete" call.
func (c *SubscriptionsDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.subscriptions.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type SubscriptionsInsertCall struct {
	s            *Service
	subscription *Subscription
	urlParams_   gensupport.URLParams
	ctx_         context.Context
	header_      http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include.
func (r *SubscriptionsService) Insert(part []string, subscription *Subscription) *SubscriptionsInsertCall {
	c := &SubscriptionsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.subscription = subscription
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *SubscriptionsInsertCall) Fields(s ...googleapi.Field) *SubscriptionsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *SubscriptionsInsertCall) Context(ctx context.Context) *SubscriptionsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *SubscriptionsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *SubscriptionsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.subscription)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/subscriptions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.subscriptions.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.subscriptions.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *Subscription.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 (c *SubscriptionsInsertCall) Do(opts ...googleapi.CallOption) (*Subscription, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Subscription{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.subscriptions.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type SubscriptionsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     subscription resource properties that the API response will include. If
//     the parameter identifies a property that contains child properties, the
//     child properties will be included in the response. For example, in a
//     subscription resource, the snippet property contains other properties,
//     such as a display title for the subscription. If you set *part=snippet*,
//     the API response will also contain all of those nested properties.
func (r *SubscriptionsService) List(part []string) *SubscriptionsListCall {
	c := &SubscriptionsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ChannelId sets the optional parameter "channelId": Return the subscriptions
// of the given channel owner.
func (c *SubscriptionsListCall) ChannelId(channelId string) *SubscriptionsListCall {
	c.urlParams_.Set("channelId", channelId)
	return c
}

// ForChannelId sets the optional parameter "forChannelId": Return the
// subscriptions to the subset of these channels that the authenticated user is
// subscribed to.
func (c *SubscriptionsListCall) ForChannelId(forChannelId string) *SubscriptionsListCall {
	c.urlParams_.Set("forChannelId", forChannelId)
	return c
}

// Id sets the optional parameter "id": Return the subscriptions with the given
// IDs for Stubby or Apiary.
func (c *SubscriptionsListCall) Id(id ...string) *SubscriptionsListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *SubscriptionsListCall) MaxResults(maxResults int64) *SubscriptionsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// Mine sets the optional parameter "mine": Flag for returning the
// subscriptions of the authenticated user.
func (c *SubscriptionsListCall) Mine(mine bool) *SubscriptionsListCall {
	c.urlParams_.Set("mine", fmt.Sprint(mine))
	return c
}

// MyRecentSubscribers sets the optional parameter "myRecentSubscribers":
func (c *SubscriptionsListCall) MyRecentSubscribers(myRecentSubscribers bool) *SubscriptionsListCall {
	c.urlParams_.Set("myRecentSubscribers", fmt.Sprint(myRecentSubscribers))
	return c
}

// MySubscribers sets the optional parameter "mySubscribers": Return the
// subscribers of the given channel owner.
func (c *SubscriptionsListCall) MySubscribers(mySubscribers bool) *SubscriptionsListCall {
	c.urlParams_.Set("mySubscribers", fmt.Sprint(mySubscribers))
	return c
}

// 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 (c *SubscriptionsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *SubscriptionsListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *SubscriptionsListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *SubscriptionsListCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Order sets the optional parameter "order": The order of the returned
// subscriptions
//
// Possible values:
//
//	"subscriptionOrderUnspecified"
//	"relevance" (default) - Sort by relevance.
//	"unread" - Sort by order of activity.
//	"alphabetical" - Sort alphabetically.
func (c *SubscriptionsListCall) Order(order string) *SubscriptionsListCall {
	c.urlParams_.Set("order", order)
	return c
}

// 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 (c *SubscriptionsListCall) PageToken(pageToken string) *SubscriptionsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *SubscriptionsListCall) Fields(s ...googleapi.Field) *SubscriptionsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *SubscriptionsListCall) IfNoneMatch(entityTag string) *SubscriptionsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *SubscriptionsListCall) Context(ctx context.Context) *SubscriptionsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *SubscriptionsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *SubscriptionsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/subscriptions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.subscriptions.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.subscriptions.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *SubscriptionListResponse.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 (c *SubscriptionsListCall) Do(opts ...googleapi.CallOption) (*SubscriptionListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &SubscriptionListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.subscriptions.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *SubscriptionsListCall) Pages(ctx context.Context, f func(*SubscriptionListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type SuperChatEventsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the superChatEvent resource parts
//     that the API response will include. This parameter is currently not
//     supported.
func (r *SuperChatEventsService) List(part []string) *SuperChatEventsListCall {
	c := &SuperChatEventsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl": Return rendered funding amounts in
// specified language.
func (c *SuperChatEventsListCall) Hl(hl string) *SuperChatEventsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set.
func (c *SuperChatEventsListCall) MaxResults(maxResults int64) *SuperChatEventsListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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 (c *SuperChatEventsListCall) PageToken(pageToken string) *SuperChatEventsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *SuperChatEventsListCall) Fields(s ...googleapi.Field) *SuperChatEventsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *SuperChatEventsListCall) IfNoneMatch(entityTag string) *SuperChatEventsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *SuperChatEventsListCall) Context(ctx context.Context) *SuperChatEventsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *SuperChatEventsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *SuperChatEventsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/superChatEvents")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.superChatEvents.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.superChatEvents.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *SuperChatEventListResponse.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 (c *SuperChatEventsListCall) Do(opts ...googleapi.CallOption) (*SuperChatEventListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &SuperChatEventListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.superChatEvents.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *SuperChatEventsListCall) Pages(ctx context.Context, f func(*SuperChatEventListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type TestsInsertCall struct {
	s          *Service
	testitem   *TestItem
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Insert: POST method.
//
// - part: .
func (r *TestsService) Insert(part []string, testitem *TestItem) *TestsInsertCall {
	c := &TestsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.testitem = testitem
	return c
}

// ExternalChannelId sets the optional parameter "externalChannelId":
func (c *TestsInsertCall) ExternalChannelId(externalChannelId string) *TestsInsertCall {
	c.urlParams_.Set("externalChannelId", externalChannelId)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel":
func (c *TestsInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *TestsInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *TestsInsertCall) Fields(s ...googleapi.Field) *TestsInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *TestsInsertCall) Context(ctx context.Context) *TestsInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *TestsInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *TestsInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.testitem)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/tests")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.tests.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.tests.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *TestItem.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 (c *TestsInsertCall) Do(opts ...googleapi.CallOption) (*TestItem, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &TestItem{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.tests.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ThirdPartyLinksDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - linkingToken: Delete the partner links with the given linking token.
// - type: Type of the link to be deleted.
func (r *ThirdPartyLinksService) Delete(linkingToken string, type_ string) *ThirdPartyLinksDeleteCall {
	c := &ThirdPartyLinksDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("linkingToken", linkingToken)
	c.urlParams_.Set("type", type_)
	return c
}

// ExternalChannelId sets the optional parameter "externalChannelId": Channel
// ID to which changes should be applied, for delegation.
func (c *ThirdPartyLinksDeleteCall) ExternalChannelId(externalChannelId string) *ThirdPartyLinksDeleteCall {
	c.urlParams_.Set("externalChannelId", externalChannelId)
	return c
}

// Part sets the optional parameter "part": Do not use. Required for
// compatibility.
func (c *ThirdPartyLinksDeleteCall) Part(part ...string) *ThirdPartyLinksDeleteCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ThirdPartyLinksDeleteCall) Fields(s ...googleapi.Field) *ThirdPartyLinksDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ThirdPartyLinksDeleteCall) Context(ctx context.Context) *ThirdPartyLinksDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ThirdPartyLinksDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ThirdPartyLinksDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/thirdPartyLinks")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.thirdPartyLinks.delete" call.
func (c *ThirdPartyLinksDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type ThirdPartyLinksInsertCall struct {
	s              *Service
	thirdpartylink *ThirdPartyLink
	urlParams_     gensupport.URLParams
	ctx_           context.Context
	header_        http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter specifies the thirdPartyLink resource parts
//     that the API request and response will include. Supported values are
//     linkingToken, status, and snippet.
func (r *ThirdPartyLinksService) Insert(part []string, thirdpartylink *ThirdPartyLink) *ThirdPartyLinksInsertCall {
	c := &ThirdPartyLinksInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.thirdpartylink = thirdpartylink
	return c
}

// ExternalChannelId sets the optional parameter "externalChannelId": Channel
// ID to which changes should be applied, for delegation.
func (c *ThirdPartyLinksInsertCall) ExternalChannelId(externalChannelId string) *ThirdPartyLinksInsertCall {
	c.urlParams_.Set("externalChannelId", externalChannelId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ThirdPartyLinksInsertCall) Fields(s ...googleapi.Field) *ThirdPartyLinksInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ThirdPartyLinksInsertCall) Context(ctx context.Context) *ThirdPartyLinksInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ThirdPartyLinksInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ThirdPartyLinksInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.thirdpartylink)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/thirdPartyLinks")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.thirdPartyLinks.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *ThirdPartyLink.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 (c *ThirdPartyLinksInsertCall) Do(opts ...googleapi.CallOption) (*ThirdPartyLink, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ThirdPartyLink{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ThirdPartyLinksListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the thirdPartyLink resource parts
//     that the API response will include. Supported values are linkingToken,
//     status, and snippet.
func (r *ThirdPartyLinksService) List(part []string) *ThirdPartyLinksListCall {
	c := &ThirdPartyLinksListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ExternalChannelId sets the optional parameter "externalChannelId": Channel
// ID to which changes should be applied, for delegation.
func (c *ThirdPartyLinksListCall) ExternalChannelId(externalChannelId string) *ThirdPartyLinksListCall {
	c.urlParams_.Set("externalChannelId", externalChannelId)
	return c
}

// LinkingToken sets the optional parameter "linkingToken": Get a third party
// link with the given linking token.
func (c *ThirdPartyLinksListCall) LinkingToken(linkingToken string) *ThirdPartyLinksListCall {
	c.urlParams_.Set("linkingToken", linkingToken)
	return c
}

// Type sets the optional parameter "type": Get a third party link of the given
// type.
//
// Possible values:
//
//	"linkUnspecified"
//	"channelToStoreLink" - A link that is connecting (or about to connect) a
//
// channel with a store on a merchandising platform in order to enable retail
// commerce capabilities for that channel on YouTube.
//
//	"channelToAffiliateProgramLink" - A link that is connecting (or about to
//
// connect) a channel with an affiliate program of a partner to enable that
// channel to earn commissions from that partner through affiliate links.
func (c *ThirdPartyLinksListCall) Type(type_ string) *ThirdPartyLinksListCall {
	c.urlParams_.Set("type", type_)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ThirdPartyLinksListCall) Fields(s ...googleapi.Field) *ThirdPartyLinksListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *ThirdPartyLinksListCall) IfNoneMatch(entityTag string) *ThirdPartyLinksListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ThirdPartyLinksListCall) Context(ctx context.Context) *ThirdPartyLinksListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ThirdPartyLinksListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ThirdPartyLinksListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/thirdPartyLinks")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.thirdPartyLinks.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ThirdPartyLinkListResponse.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 (c *ThirdPartyLinksListCall) Do(opts ...googleapi.CallOption) (*ThirdPartyLinkListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ThirdPartyLinkListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ThirdPartyLinksUpdateCall struct {
	s              *Service
	thirdpartylink *ThirdPartyLink
	urlParams_     gensupport.URLParams
	ctx_           context.Context
	header_        http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter specifies the thirdPartyLink resource parts
//     that the API request and response will include. Supported values are
//     linkingToken, status, and snippet.
func (r *ThirdPartyLinksService) Update(part []string, thirdpartylink *ThirdPartyLink) *ThirdPartyLinksUpdateCall {
	c := &ThirdPartyLinksUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.thirdpartylink = thirdpartylink
	return c
}

// ExternalChannelId sets the optional parameter "externalChannelId": Channel
// ID to which changes should be applied, for delegation.
func (c *ThirdPartyLinksUpdateCall) ExternalChannelId(externalChannelId string) *ThirdPartyLinksUpdateCall {
	c.urlParams_.Set("externalChannelId", externalChannelId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ThirdPartyLinksUpdateCall) Fields(s ...googleapi.Field) *ThirdPartyLinksUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *ThirdPartyLinksUpdateCall) Context(ctx context.Context) *ThirdPartyLinksUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ThirdPartyLinksUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ThirdPartyLinksUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.thirdpartylink)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/thirdPartyLinks")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.thirdPartyLinks.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *ThirdPartyLink.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 (c *ThirdPartyLinksUpdateCall) Do(opts ...googleapi.CallOption) (*ThirdPartyLink, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ThirdPartyLink{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.thirdPartyLinks.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ThumbnailsSetCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	mediaInfo_ *gensupport.MediaInfo
	ctx_       context.Context
	header_    http.Header
}

// Set: As this is not an insert in a strict sense (it supports
// uploading/setting of a thumbnail for multiple videos, which doesn't result
// in creation of a single resource), I use a custom verb here.
//
//   - videoId: Returns the Thumbnail with the given video IDs for Stubby or
//     Apiary.
func (r *ThumbnailsService) Set(videoId string) *ThumbnailsSetCall {
	c := &ThumbnailsSetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("videoId", videoId)
	return c
}

// 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 (c *ThumbnailsSetCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *ThumbnailsSetCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// 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 (c *ThumbnailsSetCall) Media(r io.Reader, options ...googleapi.MediaOption) *ThumbnailsSetCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *ThumbnailsSetCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *ThumbnailsSetCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *ThumbnailsSetCall) ProgressUpdater(pu googleapi.ProgressUpdater) *ThumbnailsSetCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *ThumbnailsSetCall) Fields(s ...googleapi.Field) *ThumbnailsSetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *ThumbnailsSetCall) Context(ctx context.Context) *ThumbnailsSetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *ThumbnailsSetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *ThumbnailsSetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/thumbnails/set")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/thumbnails/set")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, nil)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.thumbnails.set", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.thumbnails.set" call.
// Any non-2xx status code is an error. Response headers are in either
// *ThumbnailSetResponse.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 (c *ThumbnailsSetCall) Do(opts ...googleapi.CallOption) (*ThumbnailSetResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &ThumbnailSetResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.thumbnails.set", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideoAbuseReportReasonsListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the videoCategory resource parts that
//     the API response will include. Supported values are id and snippet.
func (r *VideoAbuseReportReasonsService) List(part []string) *VideoAbuseReportReasonsListCall {
	c := &VideoAbuseReportReasonsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl":
func (c *VideoAbuseReportReasonsListCall) Hl(hl string) *VideoAbuseReportReasonsListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideoAbuseReportReasonsListCall) Fields(s ...googleapi.Field) *VideoAbuseReportReasonsListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideoAbuseReportReasonsListCall) IfNoneMatch(entityTag string) *VideoAbuseReportReasonsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideoAbuseReportReasonsListCall) Context(ctx context.Context) *VideoAbuseReportReasonsListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideoAbuseReportReasonsListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideoAbuseReportReasonsListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videoAbuseReportReasons")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videoAbuseReportReasons.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videoAbuseReportReasons.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *VideoAbuseReportReasonListResponse.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 (c *VideoAbuseReportReasonsListCall) Do(opts ...googleapi.CallOption) (*VideoAbuseReportReasonListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &VideoAbuseReportReasonListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videoAbuseReportReasons.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideoCategoriesListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies the videoCategory resource properties
//     that the API response will include. Set the parameter value to snippet.
func (r *VideoCategoriesService) List(part []string) *VideoCategoriesListCall {
	c := &VideoCategoriesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Hl sets the optional parameter "hl":
func (c *VideoCategoriesListCall) Hl(hl string) *VideoCategoriesListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Id sets the optional parameter "id": Returns the video categories with the
// given IDs for Stubby or Apiary.
func (c *VideoCategoriesListCall) Id(id ...string) *VideoCategoriesListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// RegionCode sets the optional parameter "regionCode":
func (c *VideoCategoriesListCall) RegionCode(regionCode string) *VideoCategoriesListCall {
	c.urlParams_.Set("regionCode", regionCode)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideoCategoriesListCall) Fields(s ...googleapi.Field) *VideoCategoriesListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideoCategoriesListCall) IfNoneMatch(entityTag string) *VideoCategoriesListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideoCategoriesListCall) Context(ctx context.Context) *VideoCategoriesListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideoCategoriesListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideoCategoriesListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videoCategories")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videoCategories.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videoCategories.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *VideoCategoryListResponse.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 (c *VideoCategoriesListCall) Do(opts ...googleapi.CallOption) (*VideoCategoryListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &VideoCategoryListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videoCategories.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideoTrainabilityGetCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Get: Returns the trainability status of a video.
func (r *VideoTrainabilityService) Get() *VideoTrainabilityGetCall {
	c := &VideoTrainabilityGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// Id sets the optional parameter "id": The ID of the video to retrieve.
func (c *VideoTrainabilityGetCall) Id(id string) *VideoTrainabilityGetCall {
	c.urlParams_.Set("id", id)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideoTrainabilityGetCall) Fields(s ...googleapi.Field) *VideoTrainabilityGetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideoTrainabilityGetCall) IfNoneMatch(entityTag string) *VideoTrainabilityGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideoTrainabilityGetCall) Context(ctx context.Context) *VideoTrainabilityGetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideoTrainabilityGetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideoTrainabilityGetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videoTrainability")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videoTrainability.get", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videoTrainability.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *VideoTrainability.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 (c *VideoTrainabilityGetCall) Do(opts ...googleapi.CallOption) (*VideoTrainability, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &VideoTrainability{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videoTrainability.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideosBatchGetStatsCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// BatchGetStats: Retrieves a batch of VideoStat resources, possibly filtered.
// BatchGetStats is intentionally not atomic to provide a better user
// experience.
func (r *VideosService) BatchGetStats() *VideosBatchGetStatsCall {
	c := &VideosBatchGetStatsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// Id sets the optional parameter "id": Required. Return videos with the given
// ids. The number of IDs specified cannot exceed 50.
func (c *VideosBatchGetStatsCall) Id(id ...string) *VideosBatchGetStatsCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// 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 (c *VideosBatchGetStatsCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosBatchGetStatsCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Part sets the optional parameter "part": Required. The `**part**` parameter
// specifies a comma-separated list of one or more `videoStat` resource
// properties that the API response will include. If the parameter identifies a
// property that contains child properties, the child properties will be
// included in the response. For example, in a `videoStat` resource, the
// `statistics` property contains `view_count` and `like_count`. As such, if
// you set `**part=snippet**`, the API response will contain all of those
// properties.
func (c *VideosBatchGetStatsCall) Part(part ...string) *VideosBatchGetStatsCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosBatchGetStatsCall) Fields(s ...googleapi.Field) *VideosBatchGetStatsCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideosBatchGetStatsCall) IfNoneMatch(entityTag string) *VideosBatchGetStatsCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosBatchGetStatsCall) Context(ctx context.Context) *VideosBatchGetStatsCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosBatchGetStatsCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosBatchGetStatsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos:batchGetStats")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.batchGetStats", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.batchGetStats" call.
// Any non-2xx status code is an error. Response headers are in either
// *BatchGetStatsResponse.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 (c *VideosBatchGetStatsCall) Do(opts ...googleapi.CallOption) (*BatchGetStatsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &BatchGetStatsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.batchGetStats", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideosDeleteCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Delete: Deletes a resource.
//
// - id: .
func (r *VideosService) Delete(id string) *VideosDeleteCall {
	c := &VideosDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	return c
}

// 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 (c *VideosDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosDeleteCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosDeleteCall) Fields(s ...googleapi.Field) *VideosDeleteCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosDeleteCall) Context(ctx context.Context) *VideosDeleteCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosDeleteCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.delete" call.
func (c *VideosDeleteCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.delete", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type VideosGetRatingCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// GetRating: Retrieves the ratings that the authorized user gave to a list of
// specified videos.
//
// - id: .
func (r *VideosService) GetRating(id []string) *VideosGetRatingCall {
	c := &VideosGetRatingCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// 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 (c *VideosGetRatingCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosGetRatingCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosGetRatingCall) Fields(s ...googleapi.Field) *VideosGetRatingCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideosGetRatingCall) IfNoneMatch(entityTag string) *VideosGetRatingCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosGetRatingCall) Context(ctx context.Context) *VideosGetRatingCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosGetRatingCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosGetRatingCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos/getRating")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.getRating", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.getRating" call.
// Any non-2xx status code is an error. Response headers are in either
// *VideoGetRatingResponse.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 (c *VideosGetRatingCall) Do(opts ...googleapi.CallOption) (*VideoGetRatingResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &VideoGetRatingResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.getRating", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideosInsertCall struct {
	s          *Service
	video      *Video
	urlParams_ gensupport.URLParams
	mediaInfo_ *gensupport.MediaInfo
	ctx_       context.Context
	header_    http.Header
}

// Insert: Inserts a new resource into this collection.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. Note that not all parts
//     contain properties that can be set when inserting or updating a video. For
//     example, the statistics object encapsulates statistics that YouTube
//     calculates for a video and does not contain values that you can set or
//     modify. If the parameter value specifies a part that does not contain
//     mutable values, that part will still be included in the API response.
func (r *VideosService) Insert(part []string, video *Video) *VideosInsertCall {
	c := &VideosInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.video = video
	return c
}

// AutoLevels sets the optional parameter "autoLevels": Should auto-levels be
// applied to the upload.
func (c *VideosInsertCall) AutoLevels(autoLevels bool) *VideosInsertCall {
	c.urlParams_.Set("autoLevels", fmt.Sprint(autoLevels))
	return c
}

// NotifySubscribers sets the optional parameter "notifySubscribers": Notify
// the channel subscribers about the new video. As default, the notification is
// enabled.
func (c *VideosInsertCall) NotifySubscribers(notifySubscribers bool) *VideosInsertCall {
	c.urlParams_.Set("notifySubscribers", fmt.Sprint(notifySubscribers))
	return c
}

// 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 (c *VideosInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// OnBehalfOfContentOwnerChannel sets the optional parameter
// "onBehalfOfContentOwnerChannel": This parameter can only be used in a
// properly authorized request
// (https://developers.google.com/youtube/data/guides/authentication). *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 (c *VideosInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *VideosInsertCall {
	c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel)
	return c
}

// Stabilize sets the optional parameter "stabilize": Should stabilize be
// applied to the upload.
func (c *VideosInsertCall) Stabilize(stabilize bool) *VideosInsertCall {
	c.urlParams_.Set("stabilize", fmt.Sprint(stabilize))
	return c
}

// 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 (c *VideosInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *VideosInsertCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *VideosInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *VideosInsertCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *VideosInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *VideosInsertCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosInsertCall) Fields(s ...googleapi.Field) *VideosInsertCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *VideosInsertCall) Context(ctx context.Context) *VideosInsertCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosInsertCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosInsertCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.video)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/videos")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.insert", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.insert" call.
// Any non-2xx status code is an error. Response headers are in either
// *Video.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 (c *VideosInsertCall) Do(opts ...googleapi.CallOption) (*Video, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return nil, err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return nil, gensupport.WrapError(err)
		}
	}
	ret := &Video{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.insert", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type VideosListCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// List: Retrieves a list of resources, possibly filtered.
//
//   - part: The *part* parameter specifies a comma-separated list of one or more
//     video resource properties that the API response will include. If the
//     parameter identifies a property that contains child properties, the child
//     properties will be included in the response. For example, in a video
//     resource, the snippet property contains the channelId, title, description,
//     tags, and categoryId properties. As such, if you set *part=snippet*, the
//     API response will contain all of those properties.
func (r *VideosService) List(part []string) *VideosListCall {
	c := &VideosListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// Chart sets the optional parameter "chart": Return the videos that are in the
// specified chart.
//
// Possible values:
//
//	"chartUnspecified"
//	"mostPopular" - Return the most popular videos for the specified [content
//
// region](https://developers.google.com/youtube/data/reference/rest/v3/videos/l
// ist#regionCode) and [video
// category](https://developers.google.com/youtube/data/reference/rest/v3/videos
// /list#videoCategoryId).
func (c *VideosListCall) Chart(chart string) *VideosListCall {
	c.urlParams_.Set("chart", chart)
	return c
}

// 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 (c *VideosListCall) Hl(hl string) *VideosListCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// Id sets the optional parameter "id": Return videos with the given ids.
func (c *VideosListCall) Id(id ...string) *VideosListCall {
	c.urlParams_.SetMulti("id", append([]string{}, id...))
	return c
}

// Locale sets the optional parameter "locale":
func (c *VideosListCall) Locale(locale string) *VideosListCall {
	c.urlParams_.Set("locale", locale)
	return c
}

// MaxHeight sets the optional parameter "maxHeight":
func (c *VideosListCall) MaxHeight(maxHeight int64) *VideosListCall {
	c.urlParams_.Set("maxHeight", fmt.Sprint(maxHeight))
	return c
}

// MaxResults sets the optional parameter "maxResults": The *maxResults*
// parameter specifies the maximum number of items that should be returned in
// the result set. *Note:* This parameter is supported for use in conjunction
// with the `myRating`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#myRating)
// and `chart`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#chart)
// parameters, but it is not supported for use in conjunction with the `id`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#id)
// parameter.
func (c *VideosListCall) MaxResults(maxResults int64) *VideosListCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// MaxWidth sets the optional parameter "maxWidth": Return the player with
// maximum height specified in
func (c *VideosListCall) MaxWidth(maxWidth int64) *VideosListCall {
	c.urlParams_.Set("maxWidth", fmt.Sprint(maxWidth))
	return c
}

// MyRating sets the optional parameter "myRating": Return videos
// liked/disliked by the authenticated user. Does not support
// RateType.RATED_TYPE_NONE.
//
// Possible values:
//
//	"none" - The entity has not been rated.
//	"like" - The entity is liked.
//	"dislike" - The entity is disliked.
func (c *VideosListCall) MyRating(myRating string) *VideosListCall {
	c.urlParams_.Set("myRating", myRating)
	return c
}

// 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 (c *VideosListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosListCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// 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. *Note:* This parameter is supported for use
// in conjunction with the `myRating`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#myRating)
// and `chart`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#chart)
// parameters, but it is not supported for use in conjunction with the `id`
// (https://developers.google.com/youtube/data/reference/rest/v3/videos/list#id)
// parameter.
func (c *VideosListCall) PageToken(pageToken string) *VideosListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// RegionCode sets the optional parameter "regionCode": Use a chart that is
// specific to the specified region
func (c *VideosListCall) RegionCode(regionCode string) *VideosListCall {
	c.urlParams_.Set("regionCode", regionCode)
	return c
}

// VideoCategoryId sets the optional parameter "videoCategoryId": Use chart
// that is specific to the specified video category
func (c *VideosListCall) VideoCategoryId(videoCategoryId string) *VideosListCall {
	c.urlParams_.Set("videoCategoryId", videoCategoryId)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosListCall) Fields(s ...googleapi.Field) *VideosListCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *VideosListCall) IfNoneMatch(entityTag string) *VideosListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosListCall) Context(ctx context.Context) *VideosListCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosListCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosListCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.list", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *VideoListResponse.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 (c *VideosListCall) Do(opts ...googleapi.CallOption) (*VideoListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &VideoListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *VideosListCall) Pages(ctx context.Context, f func(*VideoListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type VideosRateCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Rate: Adds a like or dislike rating to a video or removes a rating from a
// video.
//
// - id: .
// - rating: .
func (r *VideosService) Rate(id string, rating string) *VideosRateCall {
	c := &VideosRateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("id", id)
	c.urlParams_.Set("rating", rating)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosRateCall) Fields(s ...googleapi.Field) *VideosRateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosRateCall) Context(ctx context.Context) *VideosRateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosRateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosRateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos/rate")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.rate", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.rate" call.
func (c *VideosRateCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.rate", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type VideosReportAbuseCall struct {
	s                *Service
	videoabusereport *VideoAbuseReport
	urlParams_       gensupport.URLParams
	ctx_             context.Context
	header_          http.Header
}

// ReportAbuse: Report abuse for a video.
func (r *VideosService) ReportAbuse(videoabusereport *VideoAbuseReport) *VideosReportAbuseCall {
	c := &VideosReportAbuseCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.videoabusereport = videoabusereport
	return c
}

// 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 (c *VideosReportAbuseCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosReportAbuseCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosReportAbuseCall) Fields(s ...googleapi.Field) *VideosReportAbuseCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosReportAbuseCall) Context(ctx context.Context) *VideosReportAbuseCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosReportAbuseCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosReportAbuseCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.videoabusereport)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos/reportAbuse")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.reportAbuse", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.reportAbuse" call.
func (c *VideosReportAbuseCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.reportAbuse", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type VideosUpdateCall struct {
	s          *Service
	video      *Video
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Update: Updates an existing resource.
//
//   - part: The *part* parameter serves two purposes in this operation. It
//     identifies the properties that the write operation will set as well as the
//     properties that the API response will include. Note that this method will
//     override the existing values for all of the mutable properties that are
//     contained in any parts that the parameter value specifies. For example, a
//     video's privacy setting is contained in the status part. As such, if your
//     request is updating a private video, and the request's part parameter
//     value includes the status part, the video's privacy setting will be
//     updated to whatever value the request body specifies. If the request body
//     does not specify a value, the existing privacy setting will be removed and
//     the video will revert to the default privacy setting. In addition, not all
//     parts contain properties that can be set when inserting or updating a
//     video. For example, the statistics object encapsulates statistics that
//     YouTube calculates for a video and does not contain values that you can
//     set or modify. If the parameter value specifies a part that does not
//     contain mutable values, that part will still be included in the API
//     response.
func (r *VideosService) Update(part []string, video *Video) *VideosUpdateCall {
	c := &VideosUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	c.video = video
	return c
}

// 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 (c *VideosUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *VideosUpdateCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *VideosUpdateCall) Fields(s ...googleapi.Field) *VideosUpdateCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *VideosUpdateCall) Context(ctx context.Context) *VideosUpdateCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *VideosUpdateCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *VideosUpdateCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.video)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/videos")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PUT", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.videos.update", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.videos.update" call.
// Any non-2xx status code is an error. Response headers are in either
// *Video.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 (c *VideosUpdateCall) Do(opts ...googleapi.CallOption) (*Video, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Video{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.videos.update", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type WatermarksSetCall struct {
	s               *Service
	invideobranding *InvideoBranding
	urlParams_      gensupport.URLParams
	mediaInfo_      *gensupport.MediaInfo
	ctx_            context.Context
	header_         http.Header
}

// Set: Allows upload of watermark image and setting it for a channel.
//
// - channelId: .
func (r *WatermarksService) Set(channelId string, invideobranding *InvideoBranding) *WatermarksSetCall {
	c := &WatermarksSetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("channelId", channelId)
	c.invideobranding = invideobranding
	return c
}

// 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 (c *WatermarksSetCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *WatermarksSetCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// 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 (c *WatermarksSetCall) Media(r io.Reader, options ...googleapi.MediaOption) *WatermarksSetCall {
	c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options)
	return c
}

// 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 (c *WatermarksSetCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *WatermarksSetCall {
	c.ctx_ = ctx
	c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType)
	return c
}

// 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 (c *WatermarksSetCall) ProgressUpdater(pu googleapi.ProgressUpdater) *WatermarksSetCall {
	c.mediaInfo_.SetProgressUpdater(pu)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *WatermarksSetCall) Fields(s ...googleapi.Field) *WatermarksSetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
// This context will supersede any context previously provided to the
// ResumableMedia method.
func (c *WatermarksSetCall) Context(ctx context.Context) *WatermarksSetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *WatermarksSetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *WatermarksSetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.invideobranding)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/watermarks/set")
	if c.mediaInfo_ != nil {
		urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/youtube/v3/watermarks/set")
		c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType())
	}
	newBody, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body)
	defer cleanup()
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, newBody)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	req.GetBody = getBody
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.watermarks.set", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.watermarks.set" call.
func (c *WatermarksSetCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location"))
	if rx != nil {
		rx.Client = c.s.client
		rx.UserAgent = c.s.userAgent()
		ctx := c.ctx_
		if ctx == nil {
			ctx = context.TODO()
		}
		res, err = rx.Upload(ctx)
		if err != nil {
			return err
		}
		defer res.Body.Close()
		if err := googleapi.CheckResponse(res); err != nil {
			return gensupport.WrapError(err)
		}
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.watermarks.set", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type WatermarksUnsetCall struct {
	s          *Service
	urlParams_ gensupport.URLParams
	ctx_       context.Context
	header_    http.Header
}

// Unset: Allows removal of channel watermark.
//
// - channelId: .
func (r *WatermarksService) Unset(channelId string) *WatermarksUnsetCall {
	c := &WatermarksUnsetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.urlParams_.Set("channelId", channelId)
	return c
}

// 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 (c *WatermarksUnsetCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *WatermarksUnsetCall {
	c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner)
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *WatermarksUnsetCall) Fields(s ...googleapi.Field) *WatermarksUnsetCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *WatermarksUnsetCall) Context(ctx context.Context) *WatermarksUnsetCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *WatermarksUnsetCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *WatermarksUnsetCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/watermarks/unset")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.watermarks.unset", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.watermarks.unset" call.
func (c *WatermarksUnsetCall) Do(opts ...googleapi.CallOption) error {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if err != nil {
		return err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return gensupport.WrapError(err)
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.watermarks.unset", "response", internallog.HTTPResponse(res, nil))
	return nil
}

type YoutubeV3LiveChatMessagesStreamCall struct {
	s            *Service
	urlParams_   gensupport.URLParams
	ifNoneMatch_ string
	ctx_         context.Context
	header_      http.Header
}

// Stream: Allows a user to load live chat through a server-streamed RPC. A
// call to this method has a quota cost of 5 units.
func (r *YoutubeV3LiveChatMessagesService) Stream() *YoutubeV3LiveChatMessagesStreamCall {
	c := &YoutubeV3LiveChatMessagesStreamCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	return c
}

// Hl sets the optional parameter "hl": Specifies the localization language in
// which the system messages should be returned.
func (c *YoutubeV3LiveChatMessagesStreamCall) Hl(hl string) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("hl", hl)
	return c
}

// LiveChatId sets the optional parameter "liveChatId": The ID of the live chat
// for which messages should be returned.
func (c *YoutubeV3LiveChatMessagesStreamCall) LiveChatId(liveChatId string) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("liveChatId", liveChatId)
	return c
}

// MaxResults sets the optional parameter "maxResults": The `maxResults`
// parameter specifies the maximum number of items that should be returned in
// the result set. Not used in the streaming RPC.
func (c *YoutubeV3LiveChatMessagesStreamCall) MaxResults(maxResults int64) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("maxResults", fmt.Sprint(maxResults))
	return c
}

// 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` property identifies other pages that could
// be retrieved.
func (c *YoutubeV3LiveChatMessagesStreamCall) PageToken(pageToken string) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// Part sets the optional parameter "part": The `part` parameter specifies the
// `liveChatMessage` resource parts that the API response includes. Supported
// values are `id`, `snippet`, and `authorDetails`.
func (c *YoutubeV3LiveChatMessagesStreamCall) Part(part ...string) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.SetMulti("part", append([]string{}, part...))
	return c
}

// ProfileImageSize sets the optional parameter "profileImageSize": Specifies
// the size of the profile image that should be returned for each user.
func (c *YoutubeV3LiveChatMessagesStreamCall) ProfileImageSize(profileImageSize int64) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("profileImageSize", fmt.Sprint(profileImageSize))
	return c
}

// Fields allows partial responses to be retrieved. See
// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
// details.
func (c *YoutubeV3LiveChatMessagesStreamCall) Fields(s ...googleapi.Field) *YoutubeV3LiveChatMessagesStreamCall {
	c.urlParams_.Set("fields", googleapi.CombineFields(s))
	return c
}

// IfNoneMatch sets an 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.
func (c *YoutubeV3LiveChatMessagesStreamCall) IfNoneMatch(entityTag string) *YoutubeV3LiveChatMessagesStreamCall {
	c.ifNoneMatch_ = entityTag
	return c
}

// Context sets the context to be used in this call's Do method.
func (c *YoutubeV3LiveChatMessagesStreamCall) Context(ctx context.Context) *YoutubeV3LiveChatMessagesStreamCall {
	c.ctx_ = ctx
	return c
}

// Header returns a http.Header that can be modified by the caller to add
// headers to the request.
func (c *YoutubeV3LiveChatMessagesStreamCall) Header() http.Header {
	if c.header_ == nil {
		c.header_ = make(http.Header)
	}
	return c.header_
}

func (c *YoutubeV3LiveChatMessagesStreamCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	if c.ifNoneMatch_ != "" {
		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/liveChat/messages/stream")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("GET", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "youtube.youtube.v3.liveChat.messages.stream", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "youtube.youtube.v3.liveChat.messages.stream" call.
// Any non-2xx status code is an error. Response headers are in either
// *LiveChatMessageListResponse.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 (c *YoutubeV3LiveChatMessagesStreamCall) Do(opts ...googleapi.CallOption) (*LiveChatMessageListResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &LiveChatMessageListResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "youtube.youtube.v3.liveChat.messages.stream", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// 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 (c *YoutubeV3LiveChatMessagesStreamCall) Pages(ctx context.Context, f func(*LiveChatMessageListResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}