Documentation

Overview

Package content provides access to the Content API for Shopping.

For product documentation, see: https://developers.google.com/shopping-content/v2/

Creating a client

Usage example:

import "google.golang.org/api/content/v2"
...
ctx := context.Background()
contentService, err := content.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

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

contentService, err := content.NewService(ctx, option.WithAPIKey("AIza..."))

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

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

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

Index

Constants

View Source
const (
	// Manage your product listings and accounts for Google Shopping
	ContentScope = "https://www.googleapis.com/auth/content"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type APIService

    type APIService struct {
    	BasePath  string // API endpoint base URL
    	UserAgent string // optional additional User-Agent fragment
    
    	Accounts *AccountsService
    
    	Accountstatuses *AccountstatusesService
    
    	Accounttax *AccounttaxService
    
    	Datafeeds *DatafeedsService
    
    	Datafeedstatuses *DatafeedstatusesService
    
    	Inventory *InventoryService
    
    	Liasettings *LiasettingsService
    
    	Orderinvoices *OrderinvoicesService
    
    	Orderreports *OrderreportsService
    
    	Orderreturns *OrderreturnsService
    
    	Orders *OrdersService
    
    	Pos *PosService
    
    	Products *ProductsService
    
    	Productstatuses *ProductstatusesService
    
    	Shippingsettings *ShippingsettingsService
    	// contains filtered or unexported fields
    }

    func New

    func New(client *http.Client) (*APIService, error)

      New creates a new APIService. 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 NewService

      func NewService(ctx context.Context, opts ...option.ClientOption) (*APIService, error)

        NewService creates a new APIService.

        type Account

        type Account struct {
        	// AdultContent: Indicates whether the merchant sells adult content.
        	AdultContent bool `json:"adultContent,omitempty"`
        
        	// AdwordsLinks: List of linked AdWords accounts that are active or
        	// pending approval. To create a new link request, add a new link with
        	// status `active` to the list. It will remain in a `pending` state
        	// until approved or rejected either in the AdWords interface or through
        	// the AdWords API. To delete an active link, or to cancel a link
        	// request, remove it from the list.
        	AdwordsLinks []*AccountAdwordsLink `json:"adwordsLinks,omitempty"`
        
        	// BusinessInformation: The business information of the account.
        	BusinessInformation *AccountBusinessInformation `json:"businessInformation,omitempty"`
        
        	// GoogleMyBusinessLink: The GMB account which is linked or in the
        	// process of being linked with the Merchant Center account.
        	GoogleMyBusinessLink *AccountGoogleMyBusinessLink `json:"googleMyBusinessLink,omitempty"`
        
        	// Id: Required for update. Merchant Center account ID.
        	Id uint64 `json:"id,omitempty,string"`
        
        	// Kind: Identifies what kind of resource this is. Value: the fixed
        	// string "content#account"
        	Kind string `json:"kind,omitempty"`
        
        	// Name: Required. Display name for the account.
        	Name string `json:"name,omitempty"`
        
        	// ReviewsUrl: [DEPRECATED] This field is never returned and will be
        	// ignored if provided.
        	ReviewsUrl string `json:"reviewsUrl,omitempty"`
        
        	// SellerId: Client-specific, locally-unique, internal ID for the child
        	// account.
        	SellerId string `json:"sellerId,omitempty"`
        
        	// Users: Users with access to the account. Every account (except for
        	// subaccounts) must have at least one admin user.
        	Users []*AccountUser `json:"users,omitempty"`
        
        	// WebsiteUrl: The merchant's website.
        	WebsiteUrl string `json:"websiteUrl,omitempty"`
        
        	// YoutubeChannelLinks: List of linked YouTube channels that are active
        	// or pending approval. To create a new link request, add a new link
        	// with status `active` to the list. It will remain in a `pending` state
        	// until approved or rejected in the YT Creator Studio interface. To
        	// delete an active link, or to cancel a link request, remove it from
        	// the list.
        	YoutubeChannelLinks []*AccountYouTubeChannelLink `json:"youtubeChannelLinks,omitempty"`
        
        	// ServerResponse contains the HTTP response code and headers from the
        	// server.
        	googleapi.ServerResponse `json:"-"`
        
        	// ForceSendFields is a list of field names (e.g. "AdultContent") to
        	// unconditionally include in API requests. By default, fields with
        	// empty values are omitted from API requests. However, any non-pointer,
        	// non-interface field appearing in ForceSendFields will be sent to the
        	// server regardless of whether the field is empty or not. This may be
        	// used to include empty fields in Patch requests.
        	ForceSendFields []string `json:"-"`
        
        	// NullFields is a list of field names (e.g. "AdultContent") to include
        	// in API requests with the JSON null value. By default, fields with
        	// empty values are omitted from API requests. However, any field with
        	// an empty value appearing in NullFields will be sent to the server as
        	// null. It is an error if a field in this list has a non-empty value.
        	// This may be used to include null fields in Patch requests.
        	NullFields []string `json:"-"`
        }

          Account: Account data. After the creation of a new account it may take a few minutes before it is fully operational. The methods delete, insert, and update require the admin role.

          func (*Account) MarshalJSON

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

          type AccountAddress

          type AccountAddress struct {
          	// Country: CLDR country code (e.g. "US"). This value cannot be set for
          	// a sub-account of an MCA. All MCA sub-accounts inherit the country of
          	// their parent MCA.
          	Country string `json:"country,omitempty"`
          
          	// Locality: City, town or commune. May also include dependent
          	// localities or sublocalities (e.g. neighborhoods or suburbs).
          	Locality string `json:"locality,omitempty"`
          
          	// PostalCode: Postal code or ZIP (e.g. "94043").
          	PostalCode string `json:"postalCode,omitempty"`
          
          	// Region: Top-level administrative subdivision of the country. For
          	// example, a state like California ("CA") or a province like Quebec
          	// ("QC").
          	Region string `json:"region,omitempty"`
          
          	// StreetAddress: Street-level part of the address.
          	StreetAddress string `json:"streetAddress,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Country") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "Country") to include in
          	// API requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*AccountAddress) MarshalJSON

          func (s *AccountAddress) MarshalJSON() ([]byte, error)
          type AccountAdwordsLink struct {
          	// AdwordsId: Customer ID of the AdWords account.
          	AdwordsId uint64 `json:"adwordsId,omitempty,string"`
          
          	// Status: Status of the link between this Merchant Center account and
          	// the AdWords account. Upon retrieval, it represents the actual status
          	// of the link and can be either `active` if it was approved in Google
          	// AdWords or `pending` if it's pending approval. Upon insertion, it
          	// represents the *intended* status of the link. Re-uploading a link
          	// with status `active` when it's still pending or with status `pending`
          	// when it's already active will have no effect: the status will remain
          	// unchanged. Re-uploading a link with deprecated status `inactive` is
          	// equivalent to not submitting the link at all and will delete the link
          	// if it was active or cancel the link request if it was pending.
          	// Acceptable values are: - "active" - "pending"
          	Status string `json:"status,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "AdwordsId") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "AdwordsId") to include in
          	// API requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*AccountAdwordsLink) MarshalJSON

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

          type AccountBusinessInformation

          type AccountBusinessInformation struct {
          	// Address: The address of the business.
          	Address *AccountAddress `json:"address,omitempty"`
          
          	// CustomerService: The customer service information of the business.
          	CustomerService *AccountCustomerService `json:"customerService,omitempty"`
          
          	// PhoneNumber: The phone number of the business.
          	PhoneNumber string `json:"phoneNumber,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Address") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "Address") to include in
          	// API requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*AccountBusinessInformation) MarshalJSON

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

          type AccountCustomerService

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

          func (*AccountCustomerService) MarshalJSON

          func (s *AccountCustomerService) MarshalJSON() ([]byte, error)
          type AccountGoogleMyBusinessLink struct {
          	// GmbEmail: The GMB email address of which a specific account within a
          	// GMB account. A sample account within a GMB account could be a
          	// business account with set of locations, managed under the GMB
          	// account.
          	GmbEmail string `json:"gmbEmail,omitempty"`
          
          	// Status: Status of the link between this Merchant Center account and
          	// the GMB account. Acceptable values are: - "active" - "pending"
          	Status string `json:"status,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "GmbEmail") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "GmbEmail") to include in
          	// API requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*AccountGoogleMyBusinessLink) MarshalJSON

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

          type AccountIdentifier

          type AccountIdentifier struct {
          	// AggregatorId: The aggregator ID, set for aggregators and subaccounts
          	// (in that case, it represents the aggregator of the subaccount).
          	AggregatorId uint64 `json:"aggregatorId,omitempty,string"`
          
          	// MerchantId: The merchant account ID, set for individual accounts and
          	// subaccounts.
          	MerchantId uint64 `json:"merchantId,omitempty,string"`
          
          	// ForceSendFields is a list of field names (e.g. "AggregatorId") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "AggregatorId") to include
          	// in API requests with the JSON null value. By default, fields with
          	// empty values are omitted from API requests. However, any field with
          	// an empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

          func (*AccountIdentifier) MarshalJSON

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

          type AccountStatus

          type AccountStatus struct {
          	// AccountId: The ID of the account for which the status is reported.
          	AccountId string `json:"accountId,omitempty"`
          
          	// AccountLevelIssues: A list of account level issues.
          	AccountLevelIssues []*AccountStatusAccountLevelIssue `json:"accountLevelIssues,omitempty"`
          
          	// DataQualityIssues: DEPRECATED - never populated.
          	DataQualityIssues []*AccountStatusDataQualityIssue `json:"dataQualityIssues,omitempty"`
          
          	// Kind: Identifies what kind of resource this is. Value: the fixed
          	// string "content#accountStatus"
          	Kind string `json:"kind,omitempty"`
          
          	// Products: List of product-related data by channel, destination, and
          	// country. Data in this field may be delayed by up to 30 minutes.
          	Products []*AccountStatusProducts `json:"products,omitempty"`
          
          	// WebsiteClaimed: Whether the account's website is claimed or not.
          	WebsiteClaimed bool `json:"websiteClaimed,omitempty"`
          
          	// ServerResponse contains the HTTP response code and headers from the
          	// server.
          	googleapi.ServerResponse `json:"-"`
          
          	// ForceSendFields is a list of field names (e.g. "AccountId") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "AccountId") to include in
          	// API requests with the JSON null value. By default, fields with empty
          	// values are omitted from API requests. However, any field with an
          	// empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

            AccountStatus: The status of an account, i.e., information about its products, which is computed offline and not returned immediately at insertion time.

            func (*AccountStatus) MarshalJSON

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

            type AccountStatusAccountLevelIssue

            type AccountStatusAccountLevelIssue struct {
            	// Country: Country for which this issue is reported.
            	Country string `json:"country,omitempty"`
            
            	// Destination: The destination the issue applies to. If this field is
            	// empty then the issue applies to all available destinations.
            	Destination string `json:"destination,omitempty"`
            
            	// Detail: Additional details about the issue.
            	Detail string `json:"detail,omitempty"`
            
            	// Documentation: The URL of a web page to help resolving this issue.
            	Documentation string `json:"documentation,omitempty"`
            
            	// Id: Issue identifier.
            	Id string `json:"id,omitempty"`
            
            	// Severity: Severity of the issue. Acceptable values are: -
            	// "critical" - "error" - "suggestion"
            	Severity string `json:"severity,omitempty"`
            
            	// Title: Short description of the issue.
            	Title string `json:"title,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "Country") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "Country") to include in
            	// API requests with the JSON null value. By default, fields with empty
            	// values are omitted from API requests. However, any field with an
            	// empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

            func (*AccountStatusAccountLevelIssue) MarshalJSON

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

            type AccountStatusDataQualityIssue

            type AccountStatusDataQualityIssue struct {
            	Country string `json:"country,omitempty"`
            
            	Destination string `json:"destination,omitempty"`
            
            	Detail string `json:"detail,omitempty"`
            
            	DisplayedValue string `json:"displayedValue,omitempty"`
            
            	ExampleItems []*AccountStatusExampleItem `json:"exampleItems,omitempty"`
            
            	Id string `json:"id,omitempty"`
            
            	LastChecked string `json:"lastChecked,omitempty"`
            
            	Location string `json:"location,omitempty"`
            
            	NumItems int64 `json:"numItems,omitempty"`
            
            	// Severity:  Acceptable values are: - "critical" - "error" -
            	// "suggestion"
            	Severity string `json:"severity,omitempty"`
            
            	SubmittedValue string `json:"submittedValue,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "Country") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "Country") to include in
            	// API requests with the JSON null value. By default, fields with empty
            	// values are omitted from API requests. However, any field with an
            	// empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

            func (*AccountStatusDataQualityIssue) MarshalJSON

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

            type AccountStatusExampleItem

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

            func (*AccountStatusExampleItem) MarshalJSON

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

            type AccountStatusItemLevelIssue

            type AccountStatusItemLevelIssue struct {
            	// AttributeName: The attribute's name, if the issue is caused by a
            	// single attribute.
            	AttributeName string `json:"attributeName,omitempty"`
            
            	// Code: The error code of the issue.
            	Code string `json:"code,omitempty"`
            
            	// Description: A short issue description in English.
            	Description string `json:"description,omitempty"`
            
            	// Detail: A detailed issue description in English.
            	Detail string `json:"detail,omitempty"`
            
            	// Documentation: The URL of a web page to help with resolving this
            	// issue.
            	Documentation string `json:"documentation,omitempty"`
            
            	// NumItems: Number of items with this issue.
            	NumItems int64 `json:"numItems,omitempty,string"`
            
            	// Resolution: Whether the issue can be resolved by the merchant.
            	Resolution string `json:"resolution,omitempty"`
            
            	// Servability: How this issue affects serving of the offer.
            	Servability string `json:"servability,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "AttributeName") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "AttributeName") to include
            	// in API requests with the JSON null value. By default, fields with
            	// empty values are omitted from API requests. However, any field with
            	// an empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

            func (*AccountStatusItemLevelIssue) MarshalJSON

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

            type AccountStatusProducts

            type AccountStatusProducts struct {
            	// Channel: The channel the data applies to. Acceptable values are: -
            	// "local" - "online"
            	Channel string `json:"channel,omitempty"`
            
            	// Country: The country the data applies to.
            	Country string `json:"country,omitempty"`
            
            	// Destination: The destination the data applies to.
            	Destination string `json:"destination,omitempty"`
            
            	// ItemLevelIssues: List of item-level issues.
            	ItemLevelIssues []*AccountStatusItemLevelIssue `json:"itemLevelIssues,omitempty"`
            
            	// Statistics: Aggregated product statistics.
            	Statistics *AccountStatusStatistics `json:"statistics,omitempty"`
            
            	// ForceSendFields is a list of field names (e.g. "Channel") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "Channel") to include in
            	// API requests with the JSON null value. By default, fields with empty
            	// values are omitted from API requests. However, any field with an
            	// empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

            func (*AccountStatusProducts) MarshalJSON

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

            type AccountStatusStatistics

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

            func (*AccountStatusStatistics) MarshalJSON

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

            type AccountTax

            type AccountTax struct {
            	// AccountId: Required. The ID of the account to which these account tax
            	// settings belong.
            	AccountId uint64 `json:"accountId,omitempty,string"`
            
            	// Kind: Identifies what kind of resource this is. Value: the fixed
            	// string "content#accountTax".
            	Kind string `json:"kind,omitempty"`
            
            	// Rules: Tax rules. Updating the tax rules will enable US taxes (not
            	// reversible). Defining no rules is equivalent to not charging tax at
            	// all.
            	Rules []*AccountTaxTaxRule `json:"rules,omitempty"`
            
            	// ServerResponse contains the HTTP response code and headers from the
            	// server.
            	googleapi.ServerResponse `json:"-"`
            
            	// ForceSendFields is a list of field names (e.g. "AccountId") to
            	// unconditionally include in API requests. By default, fields with
            	// empty values are omitted from API requests. However, any non-pointer,
            	// non-interface field appearing in ForceSendFields will be sent to the
            	// server regardless of whether the field is empty or not. This may be
            	// used to include empty fields in Patch requests.
            	ForceSendFields []string `json:"-"`
            
            	// NullFields is a list of field names (e.g. "AccountId") to include in
            	// API requests with the JSON null value. By default, fields with empty
            	// values are omitted from API requests. However, any field with an
            	// empty value appearing in NullFields will be sent to the server as
            	// null. It is an error if a field in this list has a non-empty value.
            	// This may be used to include null fields in Patch requests.
            	NullFields []string `json:"-"`
            }

              AccountTax: The tax settings of a merchant account. All methods require the admin role.

              func (*AccountTax) MarshalJSON

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

              type AccountTaxTaxRule

              type AccountTaxTaxRule struct {
              	// Country: Country code in which tax is applicable.
              	Country string `json:"country,omitempty"`
              
              	// LocationId: Required. State (or province) is which the tax is
              	// applicable, described by its location ID (also called criteria ID).
              	LocationId uint64 `json:"locationId,omitempty,string"`
              
              	// RatePercent: Explicit tax rate in percent, represented as a floating
              	// point number without the percentage character. Must not be negative.
              	RatePercent string `json:"ratePercent,omitempty"`
              
              	// ShippingTaxed: If true, shipping charges are also taxed.
              	ShippingTaxed bool `json:"shippingTaxed,omitempty"`
              
              	// UseGlobalRate: Whether the tax rate is taken from a global tax table
              	// or specified explicitly.
              	UseGlobalRate bool `json:"useGlobalRate,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Country") to
              	// unconditionally include in API requests. By default, fields with
              	// empty values are omitted from API requests. However, any non-pointer,
              	// non-interface field appearing in ForceSendFields will be sent to the
              	// server regardless of whether the field is empty or not. This may be
              	// used to include empty fields in Patch requests.
              	ForceSendFields []string `json:"-"`
              
              	// NullFields is a list of field names (e.g. "Country") to include in
              	// API requests with the JSON null value. By default, fields with empty
              	// values are omitted from API requests. However, any field with an
              	// empty value appearing in NullFields will be sent to the server as
              	// null. It is an error if a field in this list has a non-empty value.
              	// This may be used to include null fields in Patch requests.
              	NullFields []string `json:"-"`
              }

                AccountTaxTaxRule: Tax calculation rule to apply in a state or province (USA only).

                func (*AccountTaxTaxRule) MarshalJSON

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

                type AccountUser

                type AccountUser struct {
                	// Admin: Whether user is an admin.
                	Admin *bool `json:"admin,omitempty"`
                
                	// EmailAddress: User's email address.
                	EmailAddress string `json:"emailAddress,omitempty"`
                
                	// OrderManager: Whether user is an order manager.
                	OrderManager bool `json:"orderManager,omitempty"`
                
                	// PaymentsAnalyst: Whether user can access payment statements.
                	PaymentsAnalyst bool `json:"paymentsAnalyst,omitempty"`
                
                	// PaymentsManager: Whether user can manage payment settings.
                	PaymentsManager bool `json:"paymentsManager,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "Admin") to
                	// unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "Admin") to include in API
                	// requests with the JSON null value. By default, fields with empty
                	// values are omitted from API requests. However, any field with an
                	// empty value appearing in NullFields will be sent to the server as
                	// null. It is an error if a field in this list has a non-empty value.
                	// This may be used to include null fields in Patch requests.
                	NullFields []string `json:"-"`
                }

                func (*AccountUser) MarshalJSON

                func (s *AccountUser) MarshalJSON() ([]byte, error)
                type AccountYouTubeChannelLink struct {
                	// ChannelId: Channel ID.
                	ChannelId string `json:"channelId,omitempty"`
                
                	// Status: Status of the link between this Merchant Center account and
                	// the YouTube channel. Upon retrieval, it represents the actual status
                	// of the link and can be either `active` if it was approved in YT
                	// Creator Studio or `pending` if it's pending approval. Upon insertion,
                	// it represents the *intended* status of the link. Re-uploading a link
                	// with status `active` when it's still pending or with status `pending`
                	// when it's already active will have no effect: the status will remain
                	// unchanged. Re-uploading a link with deprecated status `inactive` is
                	// equivalent to not submitting the link at all and will delete the link
                	// if it was active or cancel the link request if it was pending.
                	Status string `json:"status,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "ChannelId") to
                	// unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "ChannelId") to include in
                	// API requests with the JSON null value. By default, fields with empty
                	// values are omitted from API requests. However, any field with an
                	// empty value appearing in NullFields will be sent to the server as
                	// null. It is an error if a field in this list has a non-empty value.
                	// This may be used to include null fields in Patch requests.
                	NullFields []string `json:"-"`
                }

                func (*AccountYouTubeChannelLink) MarshalJSON

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

                type AccountsAuthInfoResponse

                type AccountsAuthInfoResponse struct {
                	// AccountIdentifiers: The account identifiers corresponding to the
                	// authenticated user. - For an individual account: only the merchant ID
                	// is defined - For an aggregator: only the aggregator ID is defined -
                	// For a subaccount of an MCA: both the merchant ID and the aggregator
                	// ID are defined.
                	AccountIdentifiers []*AccountIdentifier `json:"accountIdentifiers,omitempty"`
                
                	// Kind: Identifies what kind of resource this is. Value: the fixed
                	// string "content#accountsAuthInfoResponse".
                	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. "AccountIdentifiers")
                	// to unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "AccountIdentifiers") to
                	// include in API requests with the JSON null value. By default, fields
                	// with empty values are omitted from API requests. However, any field
                	// with an empty value appearing in NullFields will be sent to the
                	// server as null. It is an error if a field in this list has a
                	// non-empty value. This may be used to include null fields in Patch
                	// requests.
                	NullFields []string `json:"-"`
                }

                func (*AccountsAuthInfoResponse) MarshalJSON

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

                type AccountsAuthinfoCall

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

                func (*AccountsAuthinfoCall) Context

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

                  func (*AccountsAuthinfoCall) Do

                    Do executes the "content.accounts.authinfo" call. Exactly one of *AccountsAuthInfoResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountsAuthInfoResponse.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 (*AccountsAuthinfoCall) Fields

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

                      func (*AccountsAuthinfoCall) Header

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

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

                        func (*AccountsAuthinfoCall) IfNoneMatch

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

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

                          type AccountsClaimWebsiteResponse

                          type AccountsClaimWebsiteResponse struct {
                          	// Kind: Identifies what kind of resource this is. Value: the fixed
                          	// string "content#accountsClaimWebsiteResponse".
                          	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. "Kind") to
                          	// unconditionally include in API requests. By default, fields with
                          	// empty values are omitted from API requests. However, any non-pointer,
                          	// non-interface field appearing in ForceSendFields will be sent to the
                          	// server regardless of whether the field is empty or not. This may be
                          	// used to include empty fields in Patch requests.
                          	ForceSendFields []string `json:"-"`
                          
                          	// NullFields is a list of field names (e.g. "Kind") to include in API
                          	// requests with the JSON null value. By default, fields with empty
                          	// values are omitted from API requests. However, any field with an
                          	// empty value appearing in NullFields will be sent to the server as
                          	// null. It is an error if a field in this list has a non-empty value.
                          	// This may be used to include null fields in Patch requests.
                          	NullFields []string `json:"-"`
                          }

                          func (*AccountsClaimWebsiteResponse) MarshalJSON

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

                          type AccountsClaimwebsiteCall

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

                          func (*AccountsClaimwebsiteCall) Context

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

                            func (*AccountsClaimwebsiteCall) Do

                              Do executes the "content.accounts.claimwebsite" call. Exactly one of *AccountsClaimWebsiteResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountsClaimWebsiteResponse.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 (*AccountsClaimwebsiteCall) Fields

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

                                func (*AccountsClaimwebsiteCall) Header

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

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

                                  func (*AccountsClaimwebsiteCall) Overwrite

                                  func (c *AccountsClaimwebsiteCall) Overwrite(overwrite bool) *AccountsClaimwebsiteCall

                                    Overwrite sets the optional parameter "overwrite": Only available to selected merchants. When set to `True`, this flag removes any existing claim on the requested website by another account and replaces it with a claim from this account.

                                    type AccountsCustomBatchRequest

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

                                    func (*AccountsCustomBatchRequest) MarshalJSON

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

                                    type AccountsCustomBatchRequestEntry

                                    type AccountsCustomBatchRequestEntry struct {
                                    	// Account: The account to create or update. Only defined if the method
                                    	// is `insert` or `update`.
                                    	Account *Account `json:"account,omitempty"`
                                    
                                    	// AccountId: The ID of the targeted account. Only defined if the method
                                    	// is not `insert`.
                                    	AccountId uint64 `json:"accountId,omitempty,string"`
                                    
                                    	// BatchId: An entry ID, unique within the batch request.
                                    	BatchId int64 `json:"batchId,omitempty"`
                                    
                                    	// Force: Whether the account should be deleted if the account has
                                    	// offers. Only applicable if the method is `delete`.
                                    	Force bool `json:"force,omitempty"`
                                    
                                    	// LabelIds: Label IDs for the 'updatelabels' request.
                                    	LabelIds googleapi.Uint64s `json:"labelIds,omitempty"`
                                    
                                    	// LinkRequest: Details about the `link` request.
                                    	LinkRequest *AccountsCustomBatchRequestEntryLinkRequest `json:"linkRequest,omitempty"`
                                    
                                    	// MerchantId: The ID of the managing account.
                                    	MerchantId uint64 `json:"merchantId,omitempty,string"`
                                    
                                    	// Method: The method of the batch entry. Acceptable values are: -
                                    	// "claimWebsite" - "delete" - "get" - "insert" - "link" -
                                    	// "update"
                                    	Method string `json:"method,omitempty"`
                                    
                                    	// Overwrite: Only applicable if the method is `claimwebsite`. Indicates
                                    	// whether or not to take the claim from another account in case there
                                    	// is a conflict.
                                    	Overwrite bool `json:"overwrite,omitempty"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "Account") to
                                    	// unconditionally include in API requests. By default, fields with
                                    	// empty values are omitted from API requests. However, any non-pointer,
                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                    	// server regardless of whether the field is empty or not. This may be
                                    	// used to include empty fields in Patch requests.
                                    	ForceSendFields []string `json:"-"`
                                    
                                    	// NullFields is a list of field names (e.g. "Account") to include in
                                    	// API requests with the JSON null value. By default, fields with empty
                                    	// values are omitted from API requests. However, any field with an
                                    	// empty value appearing in NullFields will be sent to the server as
                                    	// null. It is an error if a field in this list has a non-empty value.
                                    	// This may be used to include null fields in Patch requests.
                                    	NullFields []string `json:"-"`
                                    }

                                      AccountsCustomBatchRequestEntry: A batch entry encoding a single non-batch accounts request.

                                      func (*AccountsCustomBatchRequestEntry) MarshalJSON

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

                                      type AccountsCustomBatchRequestEntryLinkRequest

                                      type AccountsCustomBatchRequestEntryLinkRequest struct {
                                      	// Action: Action to perform for this link. The "request" action is
                                      	// only available to select merchants. Acceptable values are: -
                                      	// "approve" - "remove" - "request"
                                      	Action string `json:"action,omitempty"`
                                      
                                      	// LinkType: Type of the link between the two accounts. Acceptable
                                      	// values are: - "channelPartner" - "eCommercePlatform"
                                      	LinkType string `json:"linkType,omitempty"`
                                      
                                      	// LinkedAccountId: The ID of the linked account.
                                      	LinkedAccountId string `json:"linkedAccountId,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Action") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Action") to include in API
                                      	// requests with the JSON null value. By default, fields with empty
                                      	// values are omitted from API requests. However, any field with an
                                      	// empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                      func (*AccountsCustomBatchRequestEntryLinkRequest) MarshalJSON

                                      type AccountsCustomBatchResponse

                                      type AccountsCustomBatchResponse struct {
                                      	// Entries: The result of the execution of the batch requests.
                                      	Entries []*AccountsCustomBatchResponseEntry `json:"entries,omitempty"`
                                      
                                      	// Kind: Identifies what kind of resource this is. Value: the fixed
                                      	// string "content#accountsCustomBatchResponse".
                                      	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. "Entries") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Entries") to include in
                                      	// API requests with the JSON null value. By default, fields with empty
                                      	// values are omitted from API requests. However, any field with an
                                      	// empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                      func (*AccountsCustomBatchResponse) MarshalJSON

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

                                      type AccountsCustomBatchResponseEntry

                                      type AccountsCustomBatchResponseEntry struct {
                                      	// Account: The retrieved, created, or updated account. Not defined if
                                      	// the method was `delete`, `claimwebsite` or `link`.
                                      	Account *Account `json:"account,omitempty"`
                                      
                                      	// BatchId: The ID of the request entry this entry responds to.
                                      	BatchId int64 `json:"batchId,omitempty"`
                                      
                                      	// Errors: A list of errors defined if and only if the request failed.
                                      	Errors *Errors `json:"errors,omitempty"`
                                      
                                      	// Kind: Identifies what kind of resource this is. Value: the fixed
                                      	// string "content#accountsCustomBatchResponseEntry"
                                      	Kind string `json:"kind,omitempty"`
                                      
                                      	// LinkStatus: Deprecated. This field is never set. Acceptable values
                                      	// are: - "active" - "inactive" - "pending"
                                      	LinkStatus string `json:"linkStatus,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Account") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Account") to include in
                                      	// API requests with the JSON null value. By default, fields with empty
                                      	// values are omitted from API requests. However, any field with an
                                      	// empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                        AccountsCustomBatchResponseEntry: A batch entry encoding a single non-batch accounts response.

                                        func (*AccountsCustomBatchResponseEntry) MarshalJSON

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

                                        type AccountsCustombatchCall

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

                                        func (*AccountsCustombatchCall) Context

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

                                          func (*AccountsCustombatchCall) Do

                                            Do executes the "content.accounts.custombatch" call. Exactly one of *AccountsCustomBatchResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountsCustomBatchResponse.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 (*AccountsCustombatchCall) DryRun

                                              DryRun sets the optional parameter "dryRun": Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

                                              func (*AccountsCustombatchCall) Fields

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

                                                func (*AccountsCustombatchCall) Header

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

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

                                                  type AccountsDeleteCall

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

                                                  func (*AccountsDeleteCall) Context

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

                                                    func (*AccountsDeleteCall) Do

                                                      Do executes the "content.accounts.delete" call.

                                                      func (*AccountsDeleteCall) DryRun

                                                      func (c *AccountsDeleteCall) DryRun(dryRun bool) *AccountsDeleteCall

                                                        DryRun sets the optional parameter "dryRun": Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

                                                        func (*AccountsDeleteCall) Fields

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

                                                          func (*AccountsDeleteCall) Force

                                                          func (c *AccountsDeleteCall) Force(force bool) *AccountsDeleteCall

                                                            Force sets the optional parameter "force": Flag to delete sub-accounts with products. The default value is false.

                                                            func (*AccountsDeleteCall) Header

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

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

                                                              type AccountsGetCall

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

                                                              func (*AccountsGetCall) Context

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

                                                                func (*AccountsGetCall) Do

                                                                func (c *AccountsGetCall) Do(opts ...googleapi.CallOption) (*Account, error)

                                                                  Do executes the "content.accounts.get" call. Exactly one of *Account or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Account.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 (*AccountsGetCall) Fields

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

                                                                    func (*AccountsGetCall) Header

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

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

                                                                      func (*AccountsGetCall) IfNoneMatch

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

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

                                                                        type AccountsInsertCall

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

                                                                        func (*AccountsInsertCall) Context

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

                                                                          func (*AccountsInsertCall) Do

                                                                            Do executes the "content.accounts.insert" call. Exactly one of *Account or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Account.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 (*AccountsInsertCall) DryRun

                                                                            func (c *AccountsInsertCall) DryRun(dryRun bool) *AccountsInsertCall

                                                                              DryRun sets the optional parameter "dryRun": Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

                                                                              func (*AccountsInsertCall) Fields

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

                                                                                func (*AccountsInsertCall) Header

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

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

                                                                                  type AccountsLinkCall

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

                                                                                  func (*AccountsLinkCall) Context

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

                                                                                    func (*AccountsLinkCall) Do

                                                                                      Do executes the "content.accounts.link" call. Exactly one of *AccountsLinkResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountsLinkResponse.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 (*AccountsLinkCall) Fields

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

                                                                                        func (*AccountsLinkCall) Header

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

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

                                                                                          type AccountsLinkRequest

                                                                                          type AccountsLinkRequest struct {
                                                                                          	// Action: Action to perform for this link. The "request" action is
                                                                                          	// only available to select merchants. Acceptable values are: -
                                                                                          	// "approve" - "remove" - "request"
                                                                                          	Action string `json:"action,omitempty"`
                                                                                          
                                                                                          	// LinkType: Type of the link between the two accounts. Acceptable
                                                                                          	// values are: - "channelPartner" - "eCommercePlatform"
                                                                                          	LinkType string `json:"linkType,omitempty"`
                                                                                          
                                                                                          	// LinkedAccountId: The ID of the linked account.
                                                                                          	LinkedAccountId string `json:"linkedAccountId,omitempty"`
                                                                                          
                                                                                          	// ForceSendFields is a list of field names (e.g. "Action") to
                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                          	// used to include empty fields in Patch requests.
                                                                                          	ForceSendFields []string `json:"-"`
                                                                                          
                                                                                          	// NullFields is a list of field names (e.g. "Action") to include in API
                                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                          	NullFields []string `json:"-"`
                                                                                          }

                                                                                          func (*AccountsLinkRequest) MarshalJSON

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

                                                                                          type AccountsLinkResponse

                                                                                          type AccountsLinkResponse struct {
                                                                                          	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                          	// string "content#accountsLinkResponse".
                                                                                          	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. "Kind") to
                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                          	// used to include empty fields in Patch requests.
                                                                                          	ForceSendFields []string `json:"-"`
                                                                                          
                                                                                          	// NullFields is a list of field names (e.g. "Kind") to include in API
                                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                          	NullFields []string `json:"-"`
                                                                                          }

                                                                                          func (*AccountsLinkResponse) MarshalJSON

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

                                                                                          type AccountsListCall

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

                                                                                          func (*AccountsListCall) Context

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

                                                                                            func (*AccountsListCall) Do

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

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

                                                                                                func (*AccountsListCall) Header

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

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

                                                                                                  func (*AccountsListCall) IfNoneMatch

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

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

                                                                                                    func (*AccountsListCall) MaxResults

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

                                                                                                      MaxResults sets the optional parameter "maxResults": The maximum number of accounts to return in the response, used for paging.

                                                                                                      func (*AccountsListCall) PageToken

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

                                                                                                        PageToken sets the optional parameter "pageToken": The token returned by the previous request.

                                                                                                        func (*AccountsListCall) Pages

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

                                                                                                          type AccountsListResponse

                                                                                                          type AccountsListResponse struct {
                                                                                                          	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                          	// string "content#accountsListResponse".
                                                                                                          	Kind string `json:"kind,omitempty"`
                                                                                                          
                                                                                                          	// NextPageToken: The token for the retrieval of the next page of
                                                                                                          	// accounts.
                                                                                                          	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                          
                                                                                                          	Resources []*Account `json:"resources,omitempty"`
                                                                                                          
                                                                                                          	// ServerResponse contains the HTTP response code and headers from the
                                                                                                          	// server.
                                                                                                          	googleapi.ServerResponse `json:"-"`
                                                                                                          
                                                                                                          	// ForceSendFields is a list of field names (e.g. "Kind") to
                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                          
                                                                                                          	// NullFields is a list of field names (e.g. "Kind") to include in API
                                                                                                          	// requests with the JSON null value. By default, fields with empty
                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                          	NullFields []string `json:"-"`
                                                                                                          }

                                                                                                          func (*AccountsListResponse) MarshalJSON

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

                                                                                                          type AccountsService

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

                                                                                                          func NewAccountsService

                                                                                                          func NewAccountsService(s *APIService) *AccountsService

                                                                                                          func (*AccountsService) Authinfo

                                                                                                          func (r *AccountsService) Authinfo() *AccountsAuthinfoCall

                                                                                                            Authinfo: Returns information about the authenticated user.

                                                                                                            func (*AccountsService) Claimwebsite

                                                                                                            func (r *AccountsService) Claimwebsite(merchantId uint64, accountId uint64) *AccountsClaimwebsiteCall

                                                                                                              Claimwebsite: Claims the website of a Merchant Center sub-account.

                                                                                                              func (*AccountsService) Custombatch

                                                                                                              func (r *AccountsService) Custombatch(accountscustombatchrequest *AccountsCustomBatchRequest) *AccountsCustombatchCall

                                                                                                                Custombatch: Retrieves, inserts, updates, and deletes multiple Merchant Center (sub-)accounts in a single request.

                                                                                                                func (*AccountsService) Delete

                                                                                                                func (r *AccountsService) Delete(merchantId uint64, accountId uint64) *AccountsDeleteCall

                                                                                                                  Delete: Deletes a Merchant Center sub-account.

                                                                                                                  func (*AccountsService) Get

                                                                                                                  func (r *AccountsService) Get(merchantId uint64, accountId uint64) *AccountsGetCall

                                                                                                                    Get: Retrieves a Merchant Center account.

                                                                                                                    func (*AccountsService) Insert

                                                                                                                    func (r *AccountsService) Insert(merchantId uint64, account *Account) *AccountsInsertCall

                                                                                                                      Insert: Creates a Merchant Center sub-account.

                                                                                                                      func (r *AccountsService) Link(merchantId uint64, accountId uint64, accountslinkrequest *AccountsLinkRequest) *AccountsLinkCall

                                                                                                                        Link: Performs an action on a link between two Merchant Center accounts, namely accountId and linkedAccountId.

                                                                                                                        func (*AccountsService) List

                                                                                                                        func (r *AccountsService) List(merchantId uint64) *AccountsListCall

                                                                                                                          List: Lists the sub-accounts in your Merchant Center account.

                                                                                                                          func (*AccountsService) Update

                                                                                                                          func (r *AccountsService) Update(merchantId uint64, accountId uint64, account *Account) *AccountsUpdateCall

                                                                                                                            Update: Updates a Merchant Center account. Any fields that are not provided are deleted from the resource.

                                                                                                                            type AccountsUpdateCall

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

                                                                                                                            func (*AccountsUpdateCall) Context

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

                                                                                                                              func (*AccountsUpdateCall) Do

                                                                                                                                Do executes the "content.accounts.update" call. Exactly one of *Account or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Account.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 (*AccountsUpdateCall) DryRun

                                                                                                                                func (c *AccountsUpdateCall) DryRun(dryRun bool) *AccountsUpdateCall

                                                                                                                                  DryRun sets the optional parameter "dryRun": Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

                                                                                                                                  func (*AccountsUpdateCall) Fields

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

                                                                                                                                    func (*AccountsUpdateCall) Header

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

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

                                                                                                                                      type AccountstatusesCustomBatchRequest

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

                                                                                                                                      func (*AccountstatusesCustomBatchRequest) MarshalJSON

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

                                                                                                                                      type AccountstatusesCustomBatchRequestEntry

                                                                                                                                      type AccountstatusesCustomBatchRequestEntry struct {
                                                                                                                                      	// AccountId: The ID of the (sub-)account whose status to get.
                                                                                                                                      	AccountId uint64 `json:"accountId,omitempty,string"`
                                                                                                                                      
                                                                                                                                      	// BatchId: An entry ID, unique within the batch request.
                                                                                                                                      	BatchId int64 `json:"batchId,omitempty"`
                                                                                                                                      
                                                                                                                                      	// Destinations: If set, only issues for the specified destinations are
                                                                                                                                      	// returned, otherwise only issues for the Shopping destination.
                                                                                                                                      	Destinations []string `json:"destinations,omitempty"`
                                                                                                                                      
                                                                                                                                      	// MerchantId: The ID of the managing account.
                                                                                                                                      	MerchantId uint64 `json:"merchantId,omitempty,string"`
                                                                                                                                      
                                                                                                                                      	// Method: The method of the batch entry. Acceptable values are: -
                                                                                                                                      	// "get"
                                                                                                                                      	Method string `json:"method,omitempty"`
                                                                                                                                      
                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "AccountId") to
                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                      
                                                                                                                                      	// NullFields is a list of field names (e.g. "AccountId") to include in
                                                                                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                      }

                                                                                                                                        AccountstatusesCustomBatchRequestEntry: A batch entry encoding a single non-batch accountstatuses request.

                                                                                                                                        func (*AccountstatusesCustomBatchRequestEntry) MarshalJSON

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

                                                                                                                                        type AccountstatusesCustomBatchResponse

                                                                                                                                        type AccountstatusesCustomBatchResponse struct {
                                                                                                                                        	// Entries: The result of the execution of the batch requests.
                                                                                                                                        	Entries []*AccountstatusesCustomBatchResponseEntry `json:"entries,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                        	// string "content#accountstatusesCustomBatchResponse".
                                                                                                                                        	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. "Entries") to
                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                        
                                                                                                                                        	// NullFields is a list of field names (e.g. "Entries") to include in
                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                        }

                                                                                                                                        func (*AccountstatusesCustomBatchResponse) MarshalJSON

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

                                                                                                                                        type AccountstatusesCustomBatchResponseEntry

                                                                                                                                        type AccountstatusesCustomBatchResponseEntry struct {
                                                                                                                                        	// AccountStatus: The requested account status. Defined if and only if
                                                                                                                                        	// the request was successful.
                                                                                                                                        	AccountStatus *AccountStatus `json:"accountStatus,omitempty"`
                                                                                                                                        
                                                                                                                                        	// BatchId: The ID of the request entry this entry responds to.
                                                                                                                                        	BatchId int64 `json:"batchId,omitempty"`
                                                                                                                                        
                                                                                                                                        	// Errors: A list of errors defined if and only if the request failed.
                                                                                                                                        	Errors *Errors `json:"errors,omitempty"`
                                                                                                                                        
                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "AccountStatus") to
                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                        
                                                                                                                                        	// NullFields is a list of field names (e.g. "AccountStatus") to include
                                                                                                                                        	// in API requests with the JSON null value. By default, fields with
                                                                                                                                        	// empty values are omitted from API requests. However, any field with
                                                                                                                                        	// an empty value appearing in NullFields will be sent to the server as
                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                        }

                                                                                                                                          AccountstatusesCustomBatchResponseEntry: A batch entry encoding a single non-batch accountstatuses response.

                                                                                                                                          func (*AccountstatusesCustomBatchResponseEntry) MarshalJSON

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

                                                                                                                                          type AccountstatusesCustombatchCall

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

                                                                                                                                          func (*AccountstatusesCustombatchCall) Context

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

                                                                                                                                            func (*AccountstatusesCustombatchCall) Do

                                                                                                                                              Do executes the "content.accountstatuses.custombatch" call. Exactly one of *AccountstatusesCustomBatchResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountstatusesCustomBatchResponse.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 (*AccountstatusesCustombatchCall) Fields

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

                                                                                                                                                func (*AccountstatusesCustombatchCall) Header

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

                                                                                                                                                  type AccountstatusesGetCall

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

                                                                                                                                                  func (*AccountstatusesGetCall) Context

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

                                                                                                                                                    func (*AccountstatusesGetCall) Destinations

                                                                                                                                                    func (c *AccountstatusesGetCall) Destinations(destinations ...string) *AccountstatusesGetCall

                                                                                                                                                      Destinations sets the optional parameter "destinations": If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.

                                                                                                                                                      func (*AccountstatusesGetCall) Do

                                                                                                                                                        Do executes the "content.accountstatuses.get" call. Exactly one of *AccountStatus or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccountStatus.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 (*AccountstatusesGetCall) Fields

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

                                                                                                                                                          func (*AccountstatusesGetCall) Header

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

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

                                                                                                                                                            func (*AccountstatusesGetCall) IfNoneMatch

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

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

                                                                                                                                                              type AccountstatusesListCall

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

                                                                                                                                                              func (*AccountstatusesListCall) Context

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

                                                                                                                                                                func (*AccountstatusesListCall) Destinations

                                                                                                                                                                func (c *AccountstatusesListCall) Destinations(destinations ...string) *AccountstatusesListCall

                                                                                                                                                                  Destinations sets the optional parameter "destinations": If set, only issues for the specified destinations are returned, otherwise only issues for the Shopping destination.

                                                                                                                                                                  func (*AccountstatusesListCall) Do

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

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

                                                                                                                                                                      func (*AccountstatusesListCall) Header

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

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

                                                                                                                                                                        func (*AccountstatusesListCall) IfNoneMatch

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

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

                                                                                                                                                                          func (*AccountstatusesListCall) MaxResults

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

                                                                                                                                                                            MaxResults sets the optional parameter "maxResults": The maximum number of account statuses to return in the response, used for paging.

                                                                                                                                                                            func (*AccountstatusesListCall) PageToken

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

                                                                                                                                                                              PageToken sets the optional parameter "pageToken": The token returned by the previous request.

                                                                                                                                                                              func (*AccountstatusesListCall) Pages

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

                                                                                                                                                                                type AccountstatusesListResponse

                                                                                                                                                                                type AccountstatusesListResponse struct {
                                                                                                                                                                                	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                	// string "content#accountstatusesListResponse".
                                                                                                                                                                                	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// NextPageToken: The token for the retrieval of the next page of
                                                                                                                                                                                	// account statuses.
                                                                                                                                                                                	NextPageToken string `json:"nextPageToken,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	Resources []*AccountStatus `json:"resources,omitempty"`
                                                                                                                                                                                
                                                                                                                                                                                	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                	// server.
                                                                                                                                                                                	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                
                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "Kind") to
                                                                                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                                
                                                                                                                                                                                	// NullFields is a list of field names (e.g. "Kind") to include in API
                                                                                                                                                                                	// requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                	NullFields []string `json:"-"`
                                                                                                                                                                                }

                                                                                                                                                                                func (*AccountstatusesListResponse) MarshalJSON

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

                                                                                                                                                                                type AccountstatusesService

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

                                                                                                                                                                                func NewAccountstatusesService

                                                                                                                                                                                func NewAccountstatusesService(s *APIService) *AccountstatusesService

                                                                                                                                                                                func (*AccountstatusesService) Custombatch

                                                                                                                                                                                func (r *AccountstatusesService) Custombatch(accountstatusescustombatchrequest *AccountstatusesCustomBatchRequest) *AccountstatusesCustombatchCall

                                                                                                                                                                                  Custombatch: Retrieves multiple Merchant Center account statuses in a single request.

                                                                                                                                                                                  func (*AccountstatusesService) Get

                                                                                                                                                                                  func (r *AccountstatusesService) Get(merchantId uint64, accountId uint64) *AccountstatusesGetCall

                                                                                                                                                                                    Get: Retrieves the status of a Merchant Center account. No itemLevelIssues are returned for multi-client accounts.

                                                                                                                                                                                    func (*AccountstatusesService) List

                                                                                                                                                                                      List: Lists the statuses of the sub-accounts in your Merchant Center account.

                                                                                                                                                                                      type AccounttaxCustomBatchRequest

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

                                                                                                                                                                                      func (*AccounttaxCustomBatchRequest) MarshalJSON

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

                                                                                                                                                                                      type AccounttaxCustomBatchRequestEntry

                                                                                                                                                                                      type AccounttaxCustomBatchRequestEntry struct {
                                                                                                                                                                                      	// AccountId: The ID of the account for which to get/update account tax
                                                                                                                                                                                      	// settings.
                                                                                                                                                                                      	AccountId uint64 `json:"accountId,omitempty,string"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// AccountTax: The account tax settings to update. Only defined if the
                                                                                                                                                                                      	// method is `update`.
                                                                                                                                                                                      	AccountTax *AccountTax `json:"accountTax,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// BatchId: An entry ID, unique within the batch request.
                                                                                                                                                                                      	BatchId int64 `json:"batchId,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// MerchantId: The ID of the managing account.
                                                                                                                                                                                      	MerchantId uint64 `json:"merchantId,omitempty,string"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// Method: The method of the batch entry. Acceptable values are: -
                                                                                                                                                                                      	// "get" - "update"
                                                                                                                                                                                      	Method string `json:"method,omitempty"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "AccountId") to
                                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// NullFields is a list of field names (e.g. "AccountId") to include in
                                                                                                                                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                      	NullFields []string `json:"-"`
                                                                                                                                                                                      }

                                                                                                                                                                                        AccounttaxCustomBatchRequestEntry: A batch entry encoding a single non-batch accounttax request.

                                                                                                                                                                                        func (*AccounttaxCustomBatchRequestEntry) MarshalJSON

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

                                                                                                                                                                                        type AccounttaxCustomBatchResponse

                                                                                                                                                                                        type AccounttaxCustomBatchResponse struct {
                                                                                                                                                                                        	// Entries: The result of the execution of the batch requests.
                                                                                                                                                                                        	Entries []*AccounttaxCustomBatchResponseEntry `json:"entries,omitempty"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                        	// string "content#accounttaxCustomBatchResponse".
                                                                                                                                                                                        	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. "Entries") to
                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "Entries") to include in
                                                                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                                                        }

                                                                                                                                                                                        func (*AccounttaxCustomBatchResponse) MarshalJSON

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

                                                                                                                                                                                        type AccounttaxCustomBatchResponseEntry

                                                                                                                                                                                        type AccounttaxCustomBatchResponseEntry struct {
                                                                                                                                                                                        	// AccountTax: The retrieved or updated account tax settings.
                                                                                                                                                                                        	AccountTax *AccountTax `json:"accountTax,omitempty"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// BatchId: The ID of the request entry this entry responds to.
                                                                                                                                                                                        	BatchId int64 `json:"batchId,omitempty"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// Errors: A list of errors defined if and only if the request failed.
                                                                                                                                                                                        	Errors *Errors `json:"errors,omitempty"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// Kind: Identifies what kind of resource this is. Value: the fixed
                                                                                                                                                                                        	// string "content#accounttaxCustomBatchResponseEntry"
                                                                                                                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "AccountTax") to
                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                        
                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "AccountTax") to include in
                                                                                                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                                                                                                        	NullFields []string `json:"-"`
                                                                                                                                                                                        }

                                                                                                                                                                                          AccounttaxCustomBatchResponseEntry: A batch entry encoding a single non-batch accounttax response.

                                                                                                                                                                                          func (*AccounttaxCustomBatchResponseEntry) MarshalJSON

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

                                                                                                                                                                                          type AccounttaxCustombatchCall

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

                                                                                                                                                                                          func (*AccounttaxCustombatchCall) Context

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

                                                                                                                                                                                            func (*AccounttaxCustombatchCall) Do

                                                                                                                                                                                              Do executes the "content.accounttax.custombatch" call. Exactly one of *AccounttaxCustomBatchResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *AccounttaxCustomBatchResponse.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 (*AccounttaxCustombatchCall) DryRun

                                                                                                                                                                                                DryRun sets the optional parameter "dryRun": Flag to simulate a request like in a live environment. If set to true, dry-run mode checks the validity of the request and returns errors (if any).

                                                                                                                                                                                                func (*AccounttaxCustombatchCall) Fields

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

                                                                                                                                                                                                  func (*AccounttaxCustombatchCall) Header

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

                                                                                                                                                                                                    type AccounttaxGetCall

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

                                                                                                                                                                                                    func (*AccounttaxGetCall) Context

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

                                                                                                                                                                                                      func (*AccounttaxGetCall) Do

                                                                                                                                                                                                      func (c *AccounttaxGetCall) Do(opts ...googleapi.