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

// Code generated file. DO NOT EDIT.

// Package domains provides access to the Cloud Domains API.
//
// For product documentation, see: https://cloud.google.com/domains/
//
// # Library status
//
// These client libraries are officially supported by Google. However, this
// library is considered complete and is in maintenance mode. This means
// that we will address critical bugs and security issues but will not add
// any new features.
//
// When possible, we recommend using our newer
// [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go)
// that are still actively being worked and iterated on.
//
// # Creating a client
//
// Usage example:
//
//	import "google.golang.org/api/domains/v1"
//	...
//	ctx := context.Background()
//	domainsService, err := domains.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 [google.golang.org/api/option.WithAPIKey]:
//
//	domainsService, err := domains.NewService(ctx, option.WithAPIKey("AIza..."))
//
// To use an OAuth token (e.g., a user token obtained via a three-legged OAuth
// flow, use [google.golang.org/api/option.WithTokenSource]:
//
//	config := &oauth2.Config{...}
//	// ...
//	token, err := config.Exchange(ctx, ...)
//	domainsService, err := domains.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
//
// See [google.golang.org/api/option.ClientOption] for details on options.
package domains // import "google.golang.org/api/domains/v1"

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

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

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

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

// OAuth2 scopes used by this API.
const (
	// See, edit, configure, and delete your Google Cloud data and see the email
	// address for your Google Account.
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
)

// NewService creates a new Service.
func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
	scopesOption := internaloption.WithDefaultScopes(
		"https://www.googleapis.com/auth/cloud-platform",
	)
	// NOTE: prepend, so we don't override user-specified scopes.
	opts = append([]option.ClientOption{scopesOption}, opts...)
	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
	opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
	opts = append(opts, internaloption.EnableNewAuthLibrary())
	client, endpoint, err := htransport.NewClient(ctx, opts...)
	if err != nil {
		return nil, err
	}
	s := &Service{client: client, BasePath: basePath, logger: internaloption.GetLogger(opts)}
	s.Projects = NewProjectsService(s)
	if endpoint != "" {
		s.BasePath = endpoint
	}
	return s, nil
}

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

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

	Projects *ProjectsService
}

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

func NewProjectsService(s *Service) *ProjectsService {
	rs := &ProjectsService{s: s}
	rs.Locations = NewProjectsLocationsService(s)
	return rs
}

type ProjectsService struct {
	s *Service

	Locations *ProjectsLocationsService
}

func NewProjectsLocationsService(s *Service) *ProjectsLocationsService {
	rs := &ProjectsLocationsService{s: s}
	rs.Operations = NewProjectsLocationsOperationsService(s)
	rs.Registrations = NewProjectsLocationsRegistrationsService(s)
	return rs
}

type ProjectsLocationsService struct {
	s *Service

	Operations *ProjectsLocationsOperationsService

	Registrations *ProjectsLocationsRegistrationsService
}

func NewProjectsLocationsOperationsService(s *Service) *ProjectsLocationsOperationsService {
	rs := &ProjectsLocationsOperationsService{s: s}
	return rs
}

type ProjectsLocationsOperationsService struct {
	s *Service
}

func NewProjectsLocationsRegistrationsService(s *Service) *ProjectsLocationsRegistrationsService {
	rs := &ProjectsLocationsRegistrationsService{s: s}
	return rs
}

type ProjectsLocationsRegistrationsService struct {
	s *Service
}

// AuditConfig: Specifies the audit configuration for a service. The
// configuration determines which permission types are logged, and what
// identities, if any, are exempted from logging. An AuditConfig must have one
// or more AuditLogConfigs. If there are AuditConfigs for both `allServices`
// and a specific service, the union of the two AuditConfigs is used for that
// service: the log_types specified in each AuditConfig are enabled, and the
// exempted_members in each AuditLogConfig are exempted. Example Policy with
// multiple AuditConfigs: { "audit_configs": [ { "service": "allServices",
// "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [
// "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type":
// "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com",
// "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type":
// "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For
// sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
// logging. It also exempts `jose@example.com` from DATA_READ logging, and
// `aliya@example.com` from DATA_WRITE logging.
type AuditConfig struct {
	// AuditLogConfigs: The configuration for logging of each type of permission.
	AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"`
	// Service: Specifies a service that will be enabled for audit logging. For
	// example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices`
	// is a special value that covers all services.
	Service string `json:"service,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AuditLogConfigs") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AuditLogConfigs") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// AuditLogConfig: Provides the configuration for logging a type of
// permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ",
// "exempted_members": [ "user:jose@example.com" ] }, { "log_type":
// "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while
// exempting jose@example.com from DATA_READ logging.
type AuditLogConfig struct {
	// ExemptedMembers: Specifies the identities that do not cause logging for this
	// type of permission. Follows the same format of Binding.members.
	ExemptedMembers []string `json:"exemptedMembers,omitempty"`
	// LogType: The log type that this config enables.
	//
	// Possible values:
	//   "LOG_TYPE_UNSPECIFIED" - Default case. Should never be this.
	//   "ADMIN_READ" - Admin reads. Example: CloudIAM getIamPolicy
	//   "DATA_WRITE" - Data writes. Example: CloudSQL Users create
	//   "DATA_READ" - Data reads. Example: CloudSQL Users list
	LogType string `json:"logType,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ExemptedMembers") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ExemptedMembers") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// AuthorizationCode: Defines an authorization code.
type AuthorizationCode struct {
	// Code: The Authorization Code in ASCII. It can be used to transfer the domain
	// to or from another registrar.
	Code string `json:"code,omitempty"`

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

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

// Binding: Associates `members`, or principals, with a `role`.
type Binding struct {
	// Condition: The condition that is associated with this binding. If the
	// condition evaluates to `true`, then this binding applies to the current
	// request. If the condition evaluates to `false`, then this binding does not
	// apply to the current request. However, a different role binding might grant
	// the same role to one or more of the principals in this binding. To learn
	// which resources support conditions in their IAM policies, see the IAM
	// documentation
	// (https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition *Expr `json:"condition,omitempty"`
	// Members: Specifies the principals requesting access for a Google Cloud
	// resource. `members` can have the following values: * `allUsers`: A special
	// identifier that represents anyone who is on the internet; with or without a
	// Google account. * `allAuthenticatedUsers`: A special identifier that
	// represents anyone who is authenticated with a Google account or a service
	// account. Does not include identities that come from external identity
	// providers (IdPs) through identity federation. * `user:{emailid}`: An email
	// address that represents a specific Google account. For example,
	// `alice@example.com` . * `serviceAccount:{emailid}`: An email address that
	// represents a Google service account. For example,
	// `my-other-app@appspot.gserviceaccount.com`. *
	// `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An
	// identifier for a Kubernetes service account
	// (https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts).
	// For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. *
	// `group:{emailid}`: An email address that represents a Google group. For
	// example, `admins@example.com`. * `domain:{domain}`: The G Suite domain
	// (primary) that represents all the users of that domain. For example,
	// `google.com` or `example.com`. *
	// `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/sub
	// ject/{subject_attribute_value}`: A single identity in a workforce identity
	// pool. *
	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
	// group/{group_id}`: All workforce identities in a group. *
	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
	// attribute.{attribute_name}/{attribute_value}`: All workforce identities with
	// a specific attribute value. *
	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
	// *`: All identities in a workforce identity pool. *
	// `principal://iam.googleapis.com/projects/{project_number}/locations/global/wo
	// rkloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single
	// identity in a workload identity pool. *
	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
	// /workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool
	// group. *
	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
	// /workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}
	// `: All identities in a workload identity pool with a certain attribute. *
	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
	// /workloadIdentityPools/{pool_id}/*`: All identities in a workload identity
	// pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus
	// unique identifier) representing a user that has been recently deleted. For
	// example, `alice@example.com?uid=123456789012345678901`. If the user is
	// recovered, this value reverts to `user:{emailid}` and the recovered user
	// retains the role in the binding. *
	// `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus
	// unique identifier) representing a service account that has been recently
	// deleted. For example,
	// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the
	// service account is undeleted, this value reverts to
	// `serviceAccount:{emailid}` and the undeleted service account retains the
	// role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email
	// address (plus unique identifier) representing a Google group that has been
	// recently deleted. For example,
	// `admins@example.com?uid=123456789012345678901`. If the group is recovered,
	// this value reverts to `group:{emailid}` and the recovered group retains the
	// role in the binding. *
	// `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool
	// _id}/subject/{subject_attribute_value}`: Deleted single identity in a
	// workforce identity pool. For example,
	// `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-po
	// ol-id/subject/my-subject-attribute-value`.
	Members []string `json:"members,omitempty"`
	// Role: Role that is assigned to the list of `members`, or principals. For
	// example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview
	// of the IAM roles and permissions, see the IAM documentation
	// (https://cloud.google.com/iam/docs/roles-overview). For a list of the
	// available pre-defined roles, see here
	// (https://cloud.google.com/iam/docs/understanding-roles).
	Role string `json:"role,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Condition") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Condition") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ConfigureContactSettingsRequest: Request for the `ConfigureContactSettings`
// method.
type ConfigureContactSettingsRequest struct {
	// ContactNotices: The list of contact notices that the caller acknowledges.
	// The notices needed here depend on the values specified in
	// `contact_settings`.
	//
	// Possible values:
	//   "CONTACT_NOTICE_UNSPECIFIED" - The notice is undefined.
	//   "PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT" - Required when setting the
	// `privacy` field of `ContactSettings` to `PUBLIC_CONTACT_DATA`, which exposes
	// contact data publicly.
	ContactNotices []string `json:"contactNotices,omitempty"`
	// ContactSettings: Fields of the `ContactSettings` to update.
	ContactSettings *ContactSettings `json:"contactSettings,omitempty"`
	// UpdateMask: Required. The field mask describing which fields to update as a
	// comma-separated list. For example, if only the registrant contact is being
	// updated, the `update_mask` is "registrant_contact".
	UpdateMask string `json:"updateMask,omitempty"`
	// ValidateOnly: Validate the request without actually updating the contact
	// settings.
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ContactNotices") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ContactNotices") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ConfigureDnsSettingsRequest: Request for the `ConfigureDnsSettings` method.
type ConfigureDnsSettingsRequest struct {
	// DnsSettings: Fields of the `DnsSettings` to update.
	DnsSettings *DnsSettings `json:"dnsSettings,omitempty"`
	// UpdateMask: Required. The field mask describing which fields to update as a
	// comma-separated list. For example, if only the name servers are being
	// updated for an existing Custom DNS configuration, the `update_mask` is
	// "custom_dns.name_servers". When changing the DNS provider from one type to
	// another, pass the new provider's field name as part of the field mask. For
	// example, when changing from a Google Domains DNS configuration to a Custom
	// DNS configuration, the `update_mask` is "custom_dns". //
	UpdateMask string `json:"updateMask,omitempty"`
	// ValidateOnly: Validate the request without actually updating the DNS
	// settings.
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DnsSettings") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DnsSettings") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ConfigureManagementSettingsRequest: Request for the
// `ConfigureManagementSettings` method.
type ConfigureManagementSettingsRequest struct {
	// ManagementSettings: Fields of the `ManagementSettings` to update.
	ManagementSettings *ManagementSettings `json:"managementSettings,omitempty"`
	// UpdateMask: Required. The field mask describing which fields to update as a
	// comma-separated list. For example, if only the transfer lock is being
	// updated, the `update_mask` is "transfer_lock_state".
	UpdateMask string `json:"updateMask,omitempty"`
	// ValidateOnly: Optional. If set, validates the request without actually
	// updating the management settings.
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ManagementSettings") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ManagementSettings") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Contact: Details required for a contact associated with a `Registration`.
type Contact struct {
	// Email: Required. Email address of the contact.
	Email string `json:"email,omitempty"`
	// FaxNumber: Fax number of the contact in international format. For example,
	// "+1-800-555-0123".
	FaxNumber string `json:"faxNumber,omitempty"`
	// PhoneNumber: Required. Phone number of the contact in international format.
	// For example, "+1-800-555-0123".
	PhoneNumber string `json:"phoneNumber,omitempty"`
	// PostalAddress: Required. Postal address of the contact.
	PostalAddress *PostalAddress `json:"postalAddress,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Email") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Email") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ContactSettings: Defines the contact information associated with a
// `Registration`. ICANN (https://icann.org/) requires all domain names to have
// associated contact information. The `registrant_contact` is considered the
// domain's legal owner, and often the other contacts are identical.
type ContactSettings struct {
	// AdminContact: Required. The administrative contact for the `Registration`.
	AdminContact *Contact `json:"adminContact,omitempty"`
	// Privacy: Required. Privacy setting for the contacts associated with the
	// `Registration`.
	//
	// Possible values:
	//   "CONTACT_PRIVACY_UNSPECIFIED" - The contact privacy settings are
	// undefined.
	//   "PUBLIC_CONTACT_DATA" - All the data from `ContactSettings` is publicly
	// available. When setting this option, you must also provide a
	// `PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT` in the `contact_notices` field of the
	// request.
	//   "PRIVATE_CONTACT_DATA" - Deprecated: For more information, see [Cloud
	// Domains feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). None of the data from `ContactSettings` is publicly available.
	// Instead, proxy contact data is published for your domain. Email sent to the
	// proxy email address is forwarded to the registrant's email address. Cloud
	// Domains provides this privacy proxy service at no additional cost.
	//   "REDACTED_CONTACT_DATA" - The organization name (if provided) and limited
	// non-identifying data from `ContactSettings` is available to the public (e.g.
	// country and state). The remaining data is marked as `REDACTED FOR PRIVACY`
	// in the WHOIS database. The actual information redacted depends on the
	// domain. For details, see [the registration privacy
	// article](https://support.google.com/domains/answer/3251242).
	Privacy string `json:"privacy,omitempty"`
	// RegistrantContact: Required. The registrant contact for the `Registration`.
	// *Caution: Anyone with access to this email address, phone number, and/or
	// postal address can take control of the domain.* *Warning: For new
	// `Registration`s, the registrant receives an email confirmation that they
	// must complete within 15 days to avoid domain suspension.*
	RegistrantContact *Contact `json:"registrantContact,omitempty"`
	// TechnicalContact: Required. The technical contact for the `Registration`.
	TechnicalContact *Contact `json:"technicalContact,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AdminContact") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AdminContact") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// CustomDns: Configuration for an arbitrary DNS provider.
type CustomDns struct {
	// DsRecords: The list of DS records for this domain, which are used to enable
	// DNSSEC. The domain's DNS provider can provide the values to set here. If
	// this field is empty, DNSSEC is disabled.
	DsRecords []*DsRecord `json:"dsRecords,omitempty"`
	// NameServers: Required. A list of name servers that store the DNS zone for
	// this domain. Each name server is a domain name, with Unicode domain names
	// expressed in Punycode format.
	NameServers []string `json:"nameServers,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DsRecords") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DsRecords") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// DnsSettings: Defines the DNS configuration of a `Registration`, including
// name servers, DNSSEC, and glue records.
type DnsSettings struct {
	// CustomDns: An arbitrary DNS provider identified by its name servers.
	CustomDns *CustomDns `json:"customDns,omitempty"`
	// GlueRecords: The list of glue records for this `Registration`. Commonly
	// empty.
	GlueRecords []*GlueRecord `json:"glueRecords,omitempty"`
	// GoogleDomainsDns: Deprecated: For more information, see Cloud Domains
	// feature deprecation
	// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
	// The free DNS zone provided by Google Domains (https://domains.google/).
	GoogleDomainsDns *GoogleDomainsDns `json:"googleDomainsDns,omitempty"`
	// GoogleDomainsRedirectsDataAvailable: Output only. Indicates if this
	// `Registration` has configured one of the following deprecated Google Domains
	// DNS features: * Domain forwarding (HTTP `301` and `302` response status
	// codes), * Email forwarding. See
	// https://cloud.google.com/domains/docs/deprecations/feature-deprecations for
	// more details. If any of these features is enabled call the
	// `RetrieveGoogleDomainsForwardingConfig` method to get details about the
	// feature's configuration. A forwarding configuration might not work correctly
	// if required DNS records are not present in the domain's authoritative DNS
	// Zone.
	GoogleDomainsRedirectsDataAvailable bool `json:"googleDomainsRedirectsDataAvailable,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CustomDns") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CustomDns") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Domain: A domain that the calling user manages in Google Domains.
type Domain struct {
	// DomainName: The domain name. Unicode domain names are expressed in Punycode
	// format.
	DomainName string `json:"domainName,omitempty"`
	// ResourceState: The state of this domain as a `Registration` resource.
	//
	// Possible values:
	//   "RESOURCE_STATE_UNSPECIFIED" - The assessment is undefined.
	//   "IMPORTABLE" - A `Registration` resource can be created for this domain by
	// calling `ImportDomain`.
	//   "UNSUPPORTED" - A `Registration` resource cannot be created for this
	// domain because it is not supported by Cloud Domains; for example, the
	// top-level domain is not supported or the registry charges non-standard
	// pricing for yearly renewals.
	//   "SUSPENDED" - A `Registration` resource cannot be created for this domain
	// because it is suspended and needs to be resolved with Google Domains.
	//   "EXPIRED" - A `Registration` resource cannot be created for this domain
	// because it is expired and needs to be renewed with Google Domains.
	//   "DELETED" - A `Registration` resource cannot be created for this domain
	// because it is deleted, but it may be possible to restore it with Google
	// Domains.
	ResourceState string `json:"resourceState,omitempty"`
	// YearlyPrice: Price to renew the domain for one year. Only set when
	// `resource_state` is `IMPORTABLE`.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DomainName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DomainName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// DomainForwarding: Domain forwarding configuration.
type DomainForwarding struct {
	// PathForwarding: If true, forwards the path after the domain name to the same
	// path at the new address.
	PathForwarding bool `json:"pathForwarding,omitempty"`
	// PemCertificate: The PEM-encoded certificate chain.
	PemCertificate string `json:"pemCertificate,omitempty"`
	// RedirectType: The redirect type.
	//
	// Possible values:
	//   "REDIRECT_TYPE_UNSPECIFIED" - Redirect Type is unspecified.
	//   "TEMPORARY" - 301 redirect. Allows to propagate changes to the forwarding
	// address quickly.
	//   "PERMANENT" - 302 redirect. Allows browsers to cache the forwarding
	// address. This may help the address resolve more quickly. Changes may take
	// longer to propagate
	RedirectType string `json:"redirectType,omitempty"`
	// SslEnabled: If true, the forwarding works also over HTTPS.
	SslEnabled bool `json:"sslEnabled,omitempty"`
	// Subdomain: The subdomain of the registered domain that is being forwarded.
	// E.g. `www.example.com`, `example.com` (i.e. the registered domain itself) or
	// `*.example.com` (i.e. all subdomains).
	Subdomain string `json:"subdomain,omitempty"`
	// TargetUri: The target of the domain forwarding, i.e. the path to redirect
	// the `subdomain` to.
	TargetUri string `json:"targetUri,omitempty"`
	// ForceSendFields is a list of field names (e.g. "PathForwarding") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "PathForwarding") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// DsRecord: Defines a Delegation Signer (DS) record, which is needed to enable
// DNSSEC for a domain. It contains a digest (hash) of a DNSKEY record that
// must be present in the domain's DNS zone.
type DsRecord struct {
	// Algorithm: The algorithm used to generate the referenced DNSKEY.
	//
	// Possible values:
	//   "ALGORITHM_UNSPECIFIED" - The algorithm is unspecified.
	//   "RSAMD5" - RSA/MD5. Cannot be used for new deployments.
	//   "DH" - Diffie-Hellman. Cannot be used for new deployments.
	//   "DSA" - DSA/SHA1. Not recommended for new deployments.
	//   "ECC" - ECC. Not recommended for new deployments.
	//   "RSASHA1" - RSA/SHA-1. Not recommended for new deployments.
	//   "DSANSEC3SHA1" - DSA-NSEC3-SHA1. Not recommended for new deployments.
	//   "RSASHA1NSEC3SHA1" - RSA/SHA1-NSEC3-SHA1. Not recommended for new
	// deployments.
	//   "RSASHA256" - RSA/SHA-256.
	//   "RSASHA512" - RSA/SHA-512.
	//   "ECCGOST" - GOST R 34.10-2001.
	//   "ECDSAP256SHA256" - ECDSA Curve P-256 with SHA-256.
	//   "ECDSAP384SHA384" - ECDSA Curve P-384 with SHA-384.
	//   "ED25519" - Ed25519.
	//   "ED448" - Ed448.
	//   "INDIRECT" - Reserved for Indirect Keys. Cannot be used for new
	// deployments.
	//   "PRIVATEDNS" - Private algorithm. Cannot be used for new deployments.
	//   "PRIVATEOID" - Private algorithm OID. Cannot be used for new deployments.
	Algorithm string `json:"algorithm,omitempty"`
	// Digest: The digest generated from the referenced DNSKEY.
	Digest string `json:"digest,omitempty"`
	// DigestType: The hash function used to generate the digest of the referenced
	// DNSKEY.
	//
	// Possible values:
	//   "DIGEST_TYPE_UNSPECIFIED" - The DigestType is unspecified.
	//   "SHA1" - SHA-1. Not recommended for new deployments.
	//   "SHA256" - SHA-256.
	//   "GOST3411" - GOST R 34.11-94.
	//   "SHA384" - SHA-384.
	DigestType string `json:"digestType,omitempty"`
	// KeyTag: The key tag of the record. Must be set in range 0 -- 65535.
	KeyTag int64 `json:"keyTag,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Algorithm") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Algorithm") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// EmailForwarding: Email forwarding configuration.
type EmailForwarding struct {
	// Alias: An alias recipient email that forwards emails to the
	// `target_email_address`. For example, `admin@example.com` or `*@example.com`
	// (wildcard alias forwards all the emails under the registered domain).
	Alias string `json:"alias,omitempty"`
	// TargetEmailAddress: Target email that receives emails sent to the `alias`.
	TargetEmailAddress string `json:"targetEmailAddress,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Alias") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Alias") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ExportRegistrationRequest: Deprecated: For more information, see Cloud
// Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Request for the `ExportRegistration` method.
type ExportRegistrationRequest struct {
}

// Expr: Represents a textual expression in the Common Expression Language
// (CEL) syntax. CEL is a C-like expression language. The syntax and semantics
// of CEL are documented at https://github.com/google/cel-spec. Example
// (Comparison): title: "Summary size limit" description: "Determines if a
// summary is less than 100 chars" expression: "document.summary.size() < 100"
// Example (Equality): title: "Requestor is owner" description: "Determines if
// requestor is the document owner" expression: "document.owner ==
// request.auth.claims.email" Example (Logic): title: "Public documents"
// description: "Determine whether the document should be publicly visible"
// expression: "document.type != 'private' && document.type != 'internal'"
// Example (Data Manipulation): title: "Notification string" description:
// "Create a notification string with a timestamp." expression: "'New message
// received at ' + string(document.create_time)" The exact variables and
// functions that may be referenced within an expression are determined by the
// service that evaluates it. See the service documentation for additional
// information.
type Expr struct {
	// Description: Optional. Description of the expression. This is a longer text
	// which describes the expression, e.g. when hovered over it in a UI.
	Description string `json:"description,omitempty"`
	// Expression: Textual representation of an expression in Common Expression
	// Language syntax.
	Expression string `json:"expression,omitempty"`
	// Location: Optional. String indicating the location of the expression for
	// error reporting, e.g. a file name and a position in the file.
	Location string `json:"location,omitempty"`
	// Title: Optional. Title for the expression, i.e. a short string describing
	// its purpose. This can be used e.g. in UIs which allow to enter the
	// expression.
	Title string `json:"title,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Description") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Description") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// GeoPolicy: Configures a `RRSetRoutingPolicy` that routes based on the geo
// location of the querying user.
type GeoPolicy struct {
	// EnableFencing: Without fencing, if health check fails for all configured
	// items in the current geo bucket, we failover to the next nearest geo bucket.
	// With fencing, if health checking is enabled, as long as some targets in the
	// current geo bucket are healthy, we return only the healthy targets. However,
	// if all targets are unhealthy, we don't failover to the next nearest bucket;
	// instead, we return all the items in the current bucket even when all targets
	// are unhealthy.
	EnableFencing bool `json:"enableFencing,omitempty"`
	// Item: The primary geo routing configuration. If there are multiple items
	// with the same location, an error is returned instead.
	Item []*GeoPolicyItem `json:"item,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EnableFencing") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EnableFencing") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// GeoPolicyItem: ResourceRecordSet data for one geo location.
type GeoPolicyItem struct {
	// HealthCheckedTargets: For A and AAAA types only. Endpoints to return in the
	// query result only if they are healthy. These can be specified along with
	// `rrdata` within this item.
	HealthCheckedTargets *HealthCheckTargets `json:"healthCheckedTargets,omitempty"`
	// Location: The geo-location granularity is a GCP region. This location string
	// should correspond to a GCP region. e.g. "us-east1", "southamerica-east1",
	// "asia-east1", etc.
	Location string   `json:"location,omitempty"`
	Rrdata   []string `json:"rrdata,omitempty"`
	// SignatureRrdata: DNSSEC generated signatures for all the `rrdata` within
	// this item. When using health-checked targets for DNSSEC-enabled zones, you
	// can only use at most one health-checked IP address per item.
	SignatureRrdata []string `json:"signatureRrdata,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HealthCheckedTargets") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HealthCheckedTargets") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// GlueRecord: Defines a host on your domain that is a DNS name server for your
// domain and/or other domains. Glue records are a way of making the IP address
// of a name server known, even when it serves DNS queries for its parent
// domain. For example, when `ns.example.com` is a name server for
// `example.com`, the host `ns.example.com` must have a glue record to break
// the circular DNS reference.
type GlueRecord struct {
	// HostName: Required. Domain name of the host in Punycode format.
	HostName string `json:"hostName,omitempty"`
	// Ipv4Addresses: List of IPv4 addresses corresponding to this host in the
	// standard decimal format (e.g. `198.51.100.1`). At least one of
	// `ipv4_address` and `ipv6_address` must be set.
	Ipv4Addresses []string `json:"ipv4Addresses,omitempty"`
	// Ipv6Addresses: List of IPv6 addresses corresponding to this host in the
	// standard hexadecimal format (e.g. `2001:db8::`). At least one of
	// `ipv4_address` and `ipv6_address` must be set.
	Ipv6Addresses []string `json:"ipv6Addresses,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HostName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HostName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// GoogleDomainsDns: Deprecated: For more information, see Cloud Domains
// feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Configuration for using the free DNS zone provided by Google Domains as a
// `Registration`'s `dns_provider`. You cannot configure the DNS zone itself
// using the API. To configure the DNS zone, go to Google Domains
// (https://domains.google/).
type GoogleDomainsDns struct {
	// DsRecords: Output only. The list of DS records published for this domain.
	// The list is automatically populated when `ds_state` is
	// `DS_RECORDS_PUBLISHED`, otherwise it remains empty.
	DsRecords []*DsRecord `json:"dsRecords,omitempty"`
	// DsState: Required. The state of DS records for this domain. Used to enable
	// or disable automatic DNSSEC.
	//
	// Possible values:
	//   "DS_STATE_UNSPECIFIED" - DS state is unspecified.
	//   "DS_RECORDS_UNPUBLISHED" - DNSSEC is disabled for this domain. No DS
	// records for this domain are published in the parent DNS zone.
	//   "DS_RECORDS_PUBLISHED" - DNSSEC is enabled for this domain. Appropriate DS
	// records for this domain are published in the parent DNS zone. This option is
	// valid only if the DNS zone referenced in the `Registration`'s `dns_provider`
	// field is already DNSSEC-signed.
	DsState string `json:"dsState,omitempty"`
	// NameServers: Output only. A list of name servers that store the DNS zone for
	// this domain. Each name server is a domain name, with Unicode domain names
	// expressed in Punycode format. This field is automatically populated with the
	// name servers assigned to the Google Domains DNS zone.
	NameServers []string `json:"nameServers,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DsRecords") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DsRecords") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// HealthCheckTargets: HealthCheckTargets describes endpoints to health-check
// when responding to Routing Policy queries. Only the healthy endpoints will
// be included in the response. Set either `internal_load_balancer` or
// `external_endpoints`. Do not set both.
type HealthCheckTargets struct {
	// ExternalEndpoints: The Internet IP addresses to be health checked. The
	// format matches the format of ResourceRecordSet.rrdata as defined in RFC 1035
	// (section 5) and RFC 1034 (section 3.6.1)
	ExternalEndpoints []string `json:"externalEndpoints,omitempty"`
	// InternalLoadBalancer: Configuration for internal load balancers to be health
	// checked.
	InternalLoadBalancer []*LoadBalancerTarget `json:"internalLoadBalancer,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ExternalEndpoints") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ExternalEndpoints") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ImportDomainRequest: Deprecated: For more information, see Cloud Domains
// feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Request for the `ImportDomain` method.
type ImportDomainRequest struct {
	// DomainName: Required. The domain name. Unicode domain names must be
	// expressed in Punycode format.
	DomainName string `json:"domainName,omitempty"`
	// Labels: Set of labels associated with the `Registration`.
	Labels map[string]string `json:"labels,omitempty"`
	// ForceSendFields is a list of field names (e.g. "DomainName") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "DomainName") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// InitiatePushTransferRequest: Request for the `InitiatePushTransfer` method.
type InitiatePushTransferRequest struct {
	// Tag: Required. The Tag of the new registrar. Can be found at List of
	// registrars (https://nominet.uk/registrar-list/).
	Tag string `json:"tag,omitempty"`
	// ValidateOnly: Optional. If set, validates the request without actually
	// initiating the transfer.
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Tag") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Tag") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ListLocationsResponse: The response message for Locations.ListLocations.
type ListLocationsResponse struct {
	// Locations: A list of locations that matches the specified filter in the
	// request.
	Locations []*Location `json:"locations,omitempty"`
	// NextPageToken: The standard List next-page token.
	NextPageToken string `json:"nextPageToken,omitempty"`

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

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

// ListOperationsResponse: The response message for Operations.ListOperations.
type ListOperationsResponse struct {
	// NextPageToken: The standard List next-page token.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// Operations: A list of operations that matches the specified filter in the
	// request.
	Operations []*Operation `json:"operations,omitempty"`
	// Unreachable: Unordered list. Unreachable resources. Populated when the
	// request sets `ListOperationsRequest.return_partial_success` and reads across
	// collections. For example, when attempting to list all resources across all
	// supported locations.
	Unreachable []string `json:"unreachable,omitempty"`

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

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

// ListRegistrationsResponse: Response for the `ListRegistrations` method.
type ListRegistrationsResponse struct {
	// NextPageToken: When present, there are more results to retrieve. Set
	// `page_token` to this value on a subsequent call to get the next page of
	// results.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// Registrations: A list of `Registration`s.
	Registrations []*Registration `json:"registrations,omitempty"`

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

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

// LoadBalancerTarget: The configuration for an individual load balancer to
// health check.
type LoadBalancerTarget struct {
	// IpAddress: The frontend IP address of the load balancer to health check.
	IpAddress string `json:"ipAddress,omitempty"`
	// IpProtocol: The protocol of the load balancer to health check.
	//
	// Possible values:
	//   "UNDEFINED"
	//   "TCP" - Indicates the load balancer is accessible via TCP.
	//   "UDP" - Indicates the load balancer is accessible via UDP.
	IpProtocol string `json:"ipProtocol,omitempty"`
	// LoadBalancerType: The type of load balancer specified by this target. This
	// value must match the configuration of the load balancer located at the
	// LoadBalancerTarget's IP address, port, and region. Use the following: -
	// *regionalL4ilb*: for a regional internal passthrough Network Load Balancer.
	// - *regionalL7ilb*: for a regional internal Application Load Balancer. -
	// *globalL7ilb*: for a global internal Application Load Balancer.
	//
	// Possible values:
	//   "NONE"
	//   "GLOBAL_L7ILB" - Indicates the load balancer is a Cross-Region Application
	// Load Balancer.
	//   "REGIONAL_L4ILB" - Indicates the load balancer is a Regional Network
	// Passthrough Load Balancer.
	//   "REGIONAL_L7ILB" - Indicates the load balancer is a Regional Application
	// Load Balancer.
	LoadBalancerType string `json:"loadBalancerType,omitempty"`
	// NetworkUrl: The fully qualified URL of the network that the load balancer is
	// attached to. This should be formatted like
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/networks/{ne
	// twork}`.
	NetworkUrl string `json:"networkUrl,omitempty"`
	// Port: The configured port of the load balancer.
	Port string `json:"port,omitempty"`
	// Project: The project ID in which the load balancer is located.
	Project string `json:"project,omitempty"`
	// Region: The region in which the load balancer is located.
	Region string `json:"region,omitempty"`
	// ForceSendFields is a list of field names (e.g. "IpAddress") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "IpAddress") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Location: A resource that represents a Google Cloud location.
type Location struct {
	// DisplayName: The friendly name for this location, typically a nearby city
	// name. For example, "Tokyo".
	DisplayName string `json:"displayName,omitempty"`
	// Labels: Cross-service attributes for the location. For example
	// {"cloud.googleapis.com/region": "us-east1"}
	Labels map[string]string `json:"labels,omitempty"`
	// LocationId: The canonical id for this location. For example: "us-east1".
	LocationId string `json:"locationId,omitempty"`
	// Metadata: Service-specific metadata. For example the available capacity at
	// the given location.
	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
	// Name: Resource name for the location, which may vary between
	// implementations. For example:
	// "projects/example-project/locations/us-east1"
	Name string `json:"name,omitempty"`

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

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

// ManagementSettings: Defines renewal, billing, and transfer settings for a
// `Registration`.
type ManagementSettings struct {
	// EffectiveTransferLockState: Output only. The actual transfer lock state for
	// this `Registration`.
	//
	// Possible values:
	//   "TRANSFER_LOCK_STATE_UNSPECIFIED" - The state is unspecified.
	//   "UNLOCKED" - The domain is unlocked and can be transferred to another
	// registrar.
	//   "LOCKED" - The domain is locked and cannot be transferred to another
	// registrar.
	EffectiveTransferLockState string `json:"effectiveTransferLockState,omitempty"`
	// PreferredRenewalMethod: Optional. The desired renewal method for this
	// `Registration`. The actual `renewal_method` is automatically updated to
	// reflect this choice. If unset or equal to `RENEWAL_METHOD_UNSPECIFIED`, the
	// actual `renewalMethod` is treated as if it were set to `AUTOMATIC_RENEWAL`.
	// You cannot use `RENEWAL_DISABLED` during resource creation, and you can
	// update the renewal status only when the `Registration` resource has state
	// `ACTIVE` or `SUSPENDED`. When `preferred_renewal_method` is set to
	// `AUTOMATIC_RENEWAL`, the actual `renewal_method` can be set to
	// `RENEWAL_DISABLED` in case of problems with the billing account or reported
	// domain abuse. In such cases, check the `issues` field on the `Registration`.
	// After the problem is resolved, the `renewal_method` is automatically updated
	// to `preferred_renewal_method` in a few hours.
	//
	// Possible values:
	//   "RENEWAL_METHOD_UNSPECIFIED" - The renewal method is undefined.
	//   "AUTOMATIC_RENEWAL" - The domain is automatically renewed each year.
	//   "MANUAL_RENEWAL" - Deprecated: For more information, see [Cloud Domains
	// feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). This option was never used. Use `RENEWAL_DISABLED` instead.
	//   "RENEWAL_DISABLED" - The domain won't be renewed and will expire at its
	// expiration time.
	PreferredRenewalMethod string `json:"preferredRenewalMethod,omitempty"`
	// RenewalMethod: Output only. The actual renewal method for this
	// `Registration`. When `preferred_renewal_method` is set to
	// `AUTOMATIC_RENEWAL`, the actual `renewal_method` can be equal to
	// `RENEWAL_DISABLED`—for example, when there are problems with the billing
	// account or reported domain abuse. In such cases, check the `issues` field on
	// the `Registration`. After the problem is resolved, the `renewal_method` is
	// automatically updated to `preferred_renewal_method` in a few hours.
	//
	// Possible values:
	//   "RENEWAL_METHOD_UNSPECIFIED" - The renewal method is undefined.
	//   "AUTOMATIC_RENEWAL" - The domain is automatically renewed each year.
	//   "MANUAL_RENEWAL" - Deprecated: For more information, see [Cloud Domains
	// feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). This option was never used. Use `RENEWAL_DISABLED` instead.
	//   "RENEWAL_DISABLED" - The domain won't be renewed and will expire at its
	// expiration time.
	RenewalMethod string `json:"renewalMethod,omitempty"`
	// TransferLockState: This is the desired transfer lock state for this
	// `Registration`. A transfer lock controls whether the domain can be
	// transferred to another registrar. The transfer lock state of the domain is
	// returned in the `effective_transfer_lock_state` property. The transfer lock
	// state values might be different for the following reasons: *
	// `transfer_lock_state` was updated only a short time ago. * Domains with the
	// `TRANSFER_LOCK_UNSUPPORTED_BY_REGISTRY` state are in the list of
	// `domain_properties`. These domains are always in the `UNLOCKED` state.
	//
	// Possible values:
	//   "TRANSFER_LOCK_STATE_UNSPECIFIED" - The state is unspecified.
	//   "UNLOCKED" - The domain is unlocked and can be transferred to another
	// registrar.
	//   "LOCKED" - The domain is locked and cannot be transferred to another
	// registrar.
	TransferLockState string `json:"transferLockState,omitempty"`
	// ForceSendFields is a list of field names (e.g. "EffectiveTransferLockState")
	// to unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "EffectiveTransferLockState") to
	// include in API requests with the JSON null value. By default, fields with
	// empty values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Money: Represents an amount of money with its currency type.
type Money struct {
	// CurrencyCode: The three-letter currency code defined in ISO 4217.
	CurrencyCode string `json:"currencyCode,omitempty"`
	// Nanos: Number of nano (10^-9) units of the amount. The value must be between
	// -999,999,999 and +999,999,999 inclusive. If `units` is positive, `nanos`
	// must be positive or zero. If `units` is zero, `nanos` can be positive, zero,
	// or negative. If `units` is negative, `nanos` must be negative or zero. For
	// example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000.
	Nanos int64 `json:"nanos,omitempty"`
	// Units: The whole units of the amount. For example if `currencyCode` is
	// "USD", then 1 unit is one US dollar.
	Units int64 `json:"units,omitempty,string"`
	// ForceSendFields is a list of field names (e.g. "CurrencyCode") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CurrencyCode") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Operation: This resource represents a long-running operation that is the
// result of a network API call.
type Operation struct {
	// Done: If the value is `false`, it means the operation is still in progress.
	// If `true`, the operation is completed, and either `error` or `response` is
	// available.
	Done bool `json:"done,omitempty"`
	// Error: The error result of the operation in case of failure or cancellation.
	Error *Status `json:"error,omitempty"`
	// Metadata: Service-specific metadata associated with the operation. It
	// typically contains progress information and common metadata such as create
	// time. Some services might not provide such metadata. Any method that returns
	// a long-running operation should document the metadata type, if any.
	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
	// Name: The server-assigned name, which is only unique within the same service
	// that originally returns it. If you use the default HTTP mapping, the `name`
	// should be a resource name ending with `operations/{unique_id}`.
	Name string `json:"name,omitempty"`
	// Response: The normal, successful response of the operation. If the original
	// method returns no data on success, such as `Delete`, the response is
	// `google.protobuf.Empty`. If the original method is standard
	// `Get`/`Create`/`Update`, the response should be the resource. For other
	// methods, the response should have the type `XxxResponse`, where `Xxx` is the
	// original method name. For example, if the original method name is
	// `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
	Response googleapi.RawMessage `json:"response,omitempty"`

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

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

// OperationMetadata: Represents the metadata of the long-running operation.
// Output only.
type OperationMetadata struct {
	// ApiVersion: API version used to start the operation.
	ApiVersion string `json:"apiVersion,omitempty"`
	// CreateTime: The time the operation was created.
	CreateTime string `json:"createTime,omitempty"`
	// EndTime: The time the operation finished running.
	EndTime string `json:"endTime,omitempty"`
	// StatusDetail: Human-readable status of the operation, if any.
	StatusDetail string `json:"statusDetail,omitempty"`
	// Target: Server-defined resource path for the target of the operation.
	Target string `json:"target,omitempty"`
	// Verb: Name of the verb executed by the operation.
	Verb string `json:"verb,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ApiVersion") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Policy: An Identity and Access Management (IAM) policy, which specifies
// access controls for Google Cloud resources. A `Policy` is a collection of
// `bindings`. A `binding` binds one or more `members`, or principals, to a
// single `role`. Principals can be user accounts, service accounts, Google
// groups, and domains (such as G Suite). A `role` is a named list of
// permissions; each `role` can be an IAM predefined role or a user-created
// custom role. For some types of Google Cloud resources, a `binding` can also
// specify a `condition`, which is a logical expression that allows access to a
// resource only if the expression evaluates to `true`. A condition can add
// constraints based on attributes of the request, the resource, or both. To
// learn which resources support conditions in their IAM policies, see the IAM
// documentation
// (https://cloud.google.com/iam/help/conditions/resource-policies). **JSON
// example:** ``` { "bindings": [ { "role":
// "roles/resourcemanager.organizationAdmin", "members": [
// "user:mike@example.com", "group:admins@example.com", "domain:google.com",
// "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role":
// "roles/resourcemanager.organizationViewer", "members": [
// "user:eve@example.com" ], "condition": { "title": "expirable access",
// "description": "Does not grant access after Sep 2020", "expression":
// "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
// "BwWWja0YfJA=", "version": 3 } ``` **YAML example:** ``` bindings: -
// members: - user:mike@example.com - group:admins@example.com -
// domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com
// role: roles/resourcemanager.organizationAdmin - members: -
// user:eve@example.com role: roles/resourcemanager.organizationViewer
// condition: title: expirable access description: Does not grant access after
// Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
// etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features,
// see the IAM documentation (https://cloud.google.com/iam/docs/).
type Policy struct {
	// AuditConfigs: Specifies cloud audit logging configuration for this policy.
	AuditConfigs []*AuditConfig `json:"auditConfigs,omitempty"`
	// Bindings: Associates a list of `members`, or principals, with a `role`.
	// Optionally, may specify a `condition` that determines how and when the
	// `bindings` are applied. Each of the `bindings` must contain at least one
	// principal. The `bindings` in a `Policy` can refer to up to 1,500 principals;
	// up to 250 of these principals can be Google groups. Each occurrence of a
	// principal counts towards these limits. For example, if the `bindings` grant
	// 50 different roles to `user:alice@example.com`, and not to any other
	// principal, then you can add another 1,450 principals to the `bindings` in
	// the `Policy`.
	Bindings []*Binding `json:"bindings,omitempty"`
	// Etag: `etag` is used for optimistic concurrency control as a way to help
	// prevent simultaneous updates of a policy from overwriting each other. It is
	// strongly suggested that systems make use of the `etag` in the
	// read-modify-write cycle to perform policy updates in order to avoid race
	// conditions: An `etag` is returned in the response to `getIamPolicy`, and
	// systems are expected to put that etag in the request to `setIamPolicy` to
	// ensure that their change will be applied to the same version of the policy.
	// **Important:** If you use IAM Conditions, you must include the `etag` field
	// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
	// you to overwrite a version `3` policy with a version `1` policy, and all of
	// the conditions in the version `3` policy are lost.
	Etag string `json:"etag,omitempty"`
	// Version: Specifies the format of the policy. Valid values are `0`, `1`, and
	// `3`. Requests that specify an invalid value are rejected. Any operation that
	// affects conditional role bindings must specify version `3`. This requirement
	// applies to the following operations: * Getting a policy that includes a
	// conditional role binding * Adding a conditional role binding to a policy *
	// Changing a conditional role binding in a policy * Removing any role binding,
	// with or without a condition, from a policy that includes conditions
	// **Important:** If you use IAM Conditions, you must include the `etag` field
	// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
	// you to overwrite a version `3` policy with a version `1` policy, and all of
	// the conditions in the version `3` policy are lost. If a policy does not
	// include any conditions, operations on that policy may specify any valid
	// version or leave the field unset. To learn which resources support
	// conditions in their IAM policies, see the IAM documentation
	// (https://cloud.google.com/iam/help/conditions/resource-policies).
	Version int64 `json:"version,omitempty"`

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

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

// PostalAddress: Represents a postal address, such as for postal delivery or
// payments addresses. With a postal address, a postal service can deliver
// items to a premise, P.O. box, or similar. A postal address is not intended
// to model geographical locations like roads, towns, or mountains. In typical
// usage, an address would be created by user input or from importing existing
// data, depending on the type of process. Advice on address input or editing:
// - Use an internationalization-ready address widget such as
// https://github.com/google/libaddressinput. - Users should not be presented
// with UI elements for input or editing of fields outside countries where that
// field is used. For more guidance on how to use this schema, see:
// https://support.google.com/business/answer/6397478.
type PostalAddress struct {
	// AddressLines: Unstructured address lines describing the lower levels of an
	// address. Because values in `address_lines` do not have type information and
	// may sometimes contain multiple values in a single field (for example,
	// "Austin, TX"), it is important that the line order is clear. The order of
	// address lines should be "envelope order" for the country or region of the
	// address. In places where this can vary (for example, Japan),
	// `address_language` is used to make it explicit (for example, "ja" for
	// large-to-small ordering and "ja-Latn" or "en" for small-to-large). In this
	// way, the most specific line of an address can be selected based on the
	// language. The minimum permitted structural representation of an address
	// consists of a `region_code` with all remaining information placed in the
	// `address_lines`. It would be possible to format such an address very
	// approximately without geocoding, but no semantic reasoning could be made
	// about any of the address components until it was at least partially
	// resolved. Creating an address only containing a `region_code` and
	// `address_lines` and then geocoding is the recommended way to handle
	// completely unstructured addresses (as opposed to guessing which parts of the
	// address should be localities or administrative areas).
	AddressLines []string `json:"addressLines,omitempty"`
	// AdministrativeArea: Optional. Highest administrative subdivision which is
	// used for postal addresses of a country or region. For example, this can be a
	// state, a province, an oblast, or a prefecture. For Spain, this is the
	// province and not the autonomous community (for example, "Barcelona" and not
	// "Catalonia"). Many countries don't use an administrative area in postal
	// addresses. For example, in Switzerland, this should be left unpopulated.
	AdministrativeArea string `json:"administrativeArea,omitempty"`
	// LanguageCode: Optional. BCP-47 language code of the contents of this address
	// (if known). This is often the UI language of the input form or is expected
	// to match one of the languages used in the address' country/region, or their
	// transliterated equivalents. This can affect formatting in certain countries,
	// but is not critical to the correctness of the data and will never affect any
	// validation or other non-formatting related operations. If this value is not
	// known, it should be omitted (rather than specifying a possibly incorrect
	// default). Examples: "zh-Hant", "ja", "ja-Latn", "en".
	LanguageCode string `json:"languageCode,omitempty"`
	// Locality: Optional. Generally refers to the city or town portion of the
	// address. Examples: US city, IT comune, UK post town. In regions of the world
	// where localities are not well defined or do not fit into this structure
	// well, leave `locality` empty and use `address_lines`.
	Locality string `json:"locality,omitempty"`
	// Organization: Optional. The name of the organization at the address.
	Organization string `json:"organization,omitempty"`
	// PostalCode: Optional. Postal code of the address. Not all countries use or
	// require postal codes to be present, but where they are used, they may
	// trigger additional validation with other parts of the address (for example,
	// state or zip code validation in the United States).
	PostalCode string `json:"postalCode,omitempty"`
	// Recipients: Optional. The recipient at the address. This field may, under
	// certain circumstances, contain multiline information. For example, it might
	// contain "care of" information.
	Recipients []string `json:"recipients,omitempty"`
	// RegionCode: Required. CLDR region code of the country/region of the address.
	// This is never inferred and it is up to the user to ensure the value is
	// correct. See https://cldr.unicode.org/ and
	// https://www.unicode.org/cldr/charts/30/supplemental/territory_information.html
	// for details. Example: "CH" for Switzerland.
	RegionCode string `json:"regionCode,omitempty"`
	// Revision: The schema revision of the `PostalAddress`. This must be set to 0,
	// which is the latest revision. All new revisions **must** be backward
	// compatible with old revisions.
	Revision int64 `json:"revision,omitempty"`
	// SortingCode: Optional. Additional, country-specific, sorting code. This is
	// not used in most regions. Where it is used, the value is either a string
	// like "CEDEX", optionally followed by a number (for example, "CEDEX 7"), or
	// just a number alone, representing the "sector code" (Jamaica), "delivery
	// area indicator" (Malawi) or "post office indicator" (Côte d'Ivoire).
	SortingCode string `json:"sortingCode,omitempty"`
	// Sublocality: Optional. Sublocality of the address. For example, this can be
	// a neighborhood, borough, or district.
	Sublocality string `json:"sublocality,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AddressLines") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AddressLines") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// PrimaryBackupPolicy: Configures a RRSetRoutingPolicy such that all queries
// are responded with the primary_targets if they are healthy. And if all of
// them are unhealthy, then we fallback to a geo localized policy.
type PrimaryBackupPolicy struct {
	// BackupGeoTargets: Backup targets provide a regional failover policy for the
	// otherwise global primary targets. If serving state is set to `BACKUP`, this
	// policy essentially becomes a geo routing policy.
	BackupGeoTargets *GeoPolicy `json:"backupGeoTargets,omitempty"`
	// PrimaryTargets: Endpoints that are health checked before making the routing
	// decision. Unhealthy endpoints are omitted from the results. If all endpoints
	// are unhealthy, we serve a response based on the `backup_geo_targets`.
	PrimaryTargets *HealthCheckTargets `json:"primaryTargets,omitempty"`
	// TrickleTraffic: When serving state is `PRIMARY`, this field provides the
	// option of sending a small percentage of the traffic to the backup targets.
	TrickleTraffic float64 `json:"trickleTraffic,omitempty"`
	// ForceSendFields is a list of field names (e.g. "BackupGeoTargets") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "BackupGeoTargets") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

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

// RRSetRoutingPolicy: A RRSetRoutingPolicy represents ResourceRecordSet data
// that is returned dynamically with the response varying based on configured
// properties such as geolocation or by weighted random selection.
type RRSetRoutingPolicy struct {
	Geo       *GeoPolicy `json:"geo,omitempty"`
	GeoPolicy *GeoPolicy `json:"geoPolicy,omitempty"`
	// HealthCheck: The fully qualified URL of the HealthCheck to use for this
	// RRSetRoutingPolicy. Format this URL like
	// `https://www.googleapis.com/compute/v1/projects/{project}/global/healthChecks
	// /{healthCheck}`.
	// https://cloud.google.com/compute/docs/reference/rest/v1/healthChecks
	HealthCheck   string               `json:"healthCheck,omitempty"`
	PrimaryBackup *PrimaryBackupPolicy `json:"primaryBackup,omitempty"`
	Wrr           *WrrPolicy           `json:"wrr,omitempty"`
	WrrPolicy     *WrrPolicy           `json:"wrrPolicy,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Geo") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Geo") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// RegisterDomainRequest: Request for the `RegisterDomain` method.
type RegisterDomainRequest struct {
	// ContactNotices: The list of contact notices that the caller acknowledges.
	// The notices needed here depend on the values specified in
	// `registration.contact_settings`.
	//
	// Possible values:
	//   "CONTACT_NOTICE_UNSPECIFIED" - The notice is undefined.
	//   "PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT" - Required when setting the
	// `privacy` field of `ContactSettings` to `PUBLIC_CONTACT_DATA`, which exposes
	// contact data publicly.
	ContactNotices []string `json:"contactNotices,omitempty"`
	// DomainNotices: The list of domain notices that you acknowledge. Call
	// `RetrieveRegisterParameters` to see the notices that need acknowledgement.
	//
	// Possible values:
	//   "DOMAIN_NOTICE_UNSPECIFIED" - The notice is undefined.
	//   "HSTS_PRELOADED" - Indicates that the domain is preloaded on the HTTP
	// Strict Transport Security list in browsers. Serving a website on such domain
	// requires an SSL certificate. For details, see [how to get an SSL
	// certificate](https://support.google.com/domains/answer/7638036).
	DomainNotices []string `json:"domainNotices,omitempty"`
	// Registration: Required. The complete `Registration` resource to be created.
	Registration *Registration `json:"registration,omitempty"`
	// ValidateOnly: When true, only validation is performed, without actually
	// registering the domain. Follows:
	// https://cloud.google.com/apis/design/design_patterns#request_validation
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// YearlyPrice: Required. Yearly price to register or renew the domain. The
	// value that should be put here can be obtained from
	// RetrieveRegisterParameters or SearchDomains calls.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ContactNotices") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ContactNotices") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// RegisterParameters: Parameters required to register a new domain.
type RegisterParameters struct {
	// Availability: Indicates whether the domain is available for registration.
	// This value is accurate when obtained by calling
	// `RetrieveRegisterParameters`, but is approximate when obtained by calling
	// `SearchDomains`.
	//
	// Possible values:
	//   "AVAILABILITY_UNSPECIFIED" - The availability is unspecified.
	//   "AVAILABLE" - The domain is available for registration.
	//   "UNAVAILABLE" - The domain is not available for registration. Generally
	// this means it is already registered to another party.
	//   "UNSUPPORTED" - The domain is not currently supported by Cloud Domains,
	// but may be available elsewhere.
	//   "UNKNOWN" - Cloud Domains is unable to determine domain availability,
	// generally due to system maintenance at the domain name registry.
	Availability string `json:"availability,omitempty"`
	// DomainName: The domain name. Unicode domain names are expressed in Punycode
	// format.
	DomainName string `json:"domainName,omitempty"`
	// DomainNotices: Notices about special properties of the domain.
	//
	// Possible values:
	//   "DOMAIN_NOTICE_UNSPECIFIED" - The notice is undefined.
	//   "HSTS_PRELOADED" - Indicates that the domain is preloaded on the HTTP
	// Strict Transport Security list in browsers. Serving a website on such domain
	// requires an SSL certificate. For details, see [how to get an SSL
	// certificate](https://support.google.com/domains/answer/7638036).
	DomainNotices []string `json:"domainNotices,omitempty"`
	// SupportedPrivacy: Contact privacy options that the domain supports.
	//
	// Possible values:
	//   "CONTACT_PRIVACY_UNSPECIFIED" - The contact privacy settings are
	// undefined.
	//   "PUBLIC_CONTACT_DATA" - All the data from `ContactSettings` is publicly
	// available. When setting this option, you must also provide a
	// `PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT` in the `contact_notices` field of the
	// request.
	//   "PRIVATE_CONTACT_DATA" - Deprecated: For more information, see [Cloud
	// Domains feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). None of the data from `ContactSettings` is publicly available.
	// Instead, proxy contact data is published for your domain. Email sent to the
	// proxy email address is forwarded to the registrant's email address. Cloud
	// Domains provides this privacy proxy service at no additional cost.
	//   "REDACTED_CONTACT_DATA" - The organization name (if provided) and limited
	// non-identifying data from `ContactSettings` is available to the public (e.g.
	// country and state). The remaining data is marked as `REDACTED FOR PRIVACY`
	// in the WHOIS database. The actual information redacted depends on the
	// domain. For details, see [the registration privacy
	// article](https://support.google.com/domains/answer/3251242).
	SupportedPrivacy []string `json:"supportedPrivacy,omitempty"`
	// YearlyPrice: Price to register or renew the domain for one year.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Availability") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Availability") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Registration: The `Registration` resource facilitates managing and
// configuring domain name registrations. There are several ways to create a
// new `Registration` resource: To create a new `Registration` resource, find a
// suitable domain name by calling the `SearchDomains` method with a query to
// see available domain name options. After choosing a name, call
// `RetrieveRegisterParameters` to ensure availability and obtain information
// like pricing, which is needed to build a call to `RegisterDomain`. Another
// way to create a new `Registration` is to transfer an existing domain from
// another registrar (Deprecated: For more information, see Cloud Domains
// feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)).
// First, go to the current registrar to unlock the domain for transfer and
// retrieve the domain's transfer authorization code. Then call
// `RetrieveTransferParameters` to confirm that the domain is unlocked and to
// get values needed to build a call to `TransferDomain`. Finally, you can
// create a new `Registration` by importing an existing domain managed with
// Google Domains (https://domains.google/) (Deprecated: For more information,
// see Cloud Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)).
// First, call `RetrieveImportableDomains` to list domains to which the calling
// user has sufficient access. Then call `ImportDomain` on any domain names you
// want to use with Cloud Domains.
type Registration struct {
	// ContactSettings: Required. Settings for contact information linked to the
	// `Registration`. You cannot update these with the `UpdateRegistration`
	// method. To update these settings, use the `ConfigureContactSettings` method.
	ContactSettings *ContactSettings `json:"contactSettings,omitempty"`
	// CreateTime: Output only. The creation timestamp of the `Registration`
	// resource.
	CreateTime string `json:"createTime,omitempty"`
	// DnsSettings: Settings controlling the DNS configuration of the
	// `Registration`. You cannot update these with the `UpdateRegistration`
	// method. To update these settings, use the `ConfigureDnsSettings` method.
	DnsSettings *DnsSettings `json:"dnsSettings,omitempty"`
	// DomainName: Required. Immutable. The domain name. Unicode domain names must
	// be expressed in Punycode format.
	DomainName string `json:"domainName,omitempty"`
	// DomainProperties: Output only. Special properties of the domain.
	//
	// Possible values:
	//   "DOMAIN_PROPERTY_UNSPECIFIED" - The property is undefined.
	//   "TRANSFER_LOCK_UNSUPPORTED_BY_REGISTRY" - The domain does not support
	// transfer locks due to restrictions of the registry. Such domains are
	// effectively always unlocked and any change made to
	// `management_settings.transfer_lock_state` is ignored.
	//   "REQUIRE_PUSH_TRANSFER" - The domain uses an alternative `Push Transfer`
	// process to transfer the domain to another registrar. There are two important
	// consequences: * Cloud Domains does not supply the authorization codes. * To
	// initiate the process to transfer the domain to another registrar, you must
	// provide a tag of the registrar you want to transfer to. You can do this by
	// using the `InitiatePushTransfer` method. For more information, see [Transfer
	// a registered domain to another
	// registrar](https://cloud.google.com/domains/docs/transfer-domain-to-another-r
	// egistrar).
	DomainProperties []string `json:"domainProperties,omitempty"`
	// ExpireTime: Output only. The expiration timestamp of the `Registration`.
	ExpireTime string `json:"expireTime,omitempty"`
	// Issues: Output only. The set of issues with the `Registration` that require
	// attention.
	//
	// Possible values:
	//   "ISSUE_UNSPECIFIED" - The issue is undefined.
	//   "CONTACT_SUPPORT" - Contact the Cloud Support team to resolve a problem
	// with this domain.
	//   "UNVERIFIED_EMAIL" - [ICANN](https://icann.org/) requires verification of
	// the email address in the `Registration`'s
	// `contact_settings.registrant_contact` field. To verify the email address,
	// follow the instructions in the email the `registrant_contact` receives
	// following registration. If you do not complete email verification within 15
	// days of registration, the domain is suspended. To resend the verification
	// email, call ConfigureContactSettings and provide the current
	// `registrant_contact.email`.
	//   "PROBLEM_WITH_BILLING" - The billing account is not in good standing. The
	// domain is not automatically renewed at its expiration time unless you
	// resolve problems with your billing account.
	//   "DNS_NOT_ACTIVATED" - The registry failed to validate your DNS
	// configuration and activate your domain. The failure might happen for the
	// following reasons: * You recently registered the domain (wait up to 72
	// hours). * You provided invalid name servers or name servers that correspond
	// to a newly created DNS zone. Verify your DNS configuration. If the
	// configuration is incorrect, you must fix it. If the configuration is
	// correct, either wait or call the ConfigureDnsSettings method to retry the
	// registry validation.
	//   "AUTO_RENEWAL_UPDATE_NOT_EFFECTIVE" - Due to SquareSpace's constraints,
	// the auto-renewal update you made may not be effective during a certain
	// period of time. Generally, the time period is 15 days before expiration for
	// generic TLD domains, and 15 days before expiration + 3 days after expiration
	// for country-code TLD domains.
	Issues []string `json:"issues,omitempty"`
	// Labels: Set of labels associated with the `Registration`.
	Labels map[string]string `json:"labels,omitempty"`
	// ManagementSettings: Settings for management of the `Registration`, including
	// renewal, billing, and transfer. You cannot update these with the
	// `UpdateRegistration` method. To update these settings, use the
	// `ConfigureManagementSettings` method.
	ManagementSettings *ManagementSettings `json:"managementSettings,omitempty"`
	// Name: Output only. Name of the `Registration` resource, in the format
	// `projects/*/locations/*/registrations/`.
	Name string `json:"name,omitempty"`
	// PendingContactSettings: Output only. Pending contact settings for the
	// `Registration`. Updates to the `contact_settings` field that change its
	// `registrant_contact` or `privacy` fields require email confirmation by the
	// `registrant_contact` before taking effect. This field is set only if there
	// are pending updates to the `contact_settings` that have not been confirmed.
	// To confirm the changes, the `registrant_contact` must follow the
	// instructions in the email they receive.
	PendingContactSettings *ContactSettings `json:"pendingContactSettings,omitempty"`
	// RegisterFailureReason: Output only. The reason the domain registration
	// failed. Only set for domains in REGISTRATION_FAILED state.
	//
	// Possible values:
	//   "REGISTER_FAILURE_REASON_UNSPECIFIED" - Register failure unspecified.
	//   "REGISTER_FAILURE_REASON_UNKNOWN" - Registration failed for an unknown
	// reason.
	//   "DOMAIN_NOT_AVAILABLE" - The domain is not available for registration.
	//   "INVALID_CONTACTS" - The provided contact information was rejected.
	RegisterFailureReason string `json:"registerFailureReason,omitempty"`
	// State: Output only. The state of the `Registration`
	//
	// Possible values:
	//   "STATE_UNSPECIFIED" - The state is undefined.
	//   "REGISTRATION_PENDING" - The domain is being registered.
	//   "REGISTRATION_FAILED" - The domain registration failed. You can delete
	// resources in this state to allow registration to be retried.
	//   "TRANSFER_PENDING" - The domain is being transferred from another
	// registrar to Cloud Domains.
	//   "TRANSFER_FAILED" - The attempt to transfer the domain from another
	// registrar to Cloud Domains failed. You can delete resources in this state
	// and retry the transfer.
	//   "IMPORT_PENDING" - The domain is being imported from Google Domains to
	// Cloud Domains.
	//   "ACTIVE" - The domain is registered and operational. The domain renews
	// automatically as long as it remains in this state and the `RenewalMethod` is
	// set to `AUTOMATIC_RENEWAL`.
	//   "SUSPENDED" - The domain is suspended and inoperative. For more details,
	// see the `issues` field.
	//   "EXPORTED" - The domain is no longer managed with Cloud Domains. It may
	// have been transferred to another registrar or exported for management in
	// [Google Domains](https://domains.google/). You can no longer update it with
	// this API, and information shown about it may be stale. Domains in this state
	// are not automatically renewed by Cloud Domains.
	//   "EXPIRED" - The domain is expired.
	State string `json:"state,omitempty"`
	// SupportedPrivacy: Output only. Set of options for the
	// `contact_settings.privacy` field that this `Registration` supports.
	//
	// Possible values:
	//   "CONTACT_PRIVACY_UNSPECIFIED" - The contact privacy settings are
	// undefined.
	//   "PUBLIC_CONTACT_DATA" - All the data from `ContactSettings` is publicly
	// available. When setting this option, you must also provide a
	// `PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT` in the `contact_notices` field of the
	// request.
	//   "PRIVATE_CONTACT_DATA" - Deprecated: For more information, see [Cloud
	// Domains feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). None of the data from `ContactSettings` is publicly available.
	// Instead, proxy contact data is published for your domain. Email sent to the
	// proxy email address is forwarded to the registrant's email address. Cloud
	// Domains provides this privacy proxy service at no additional cost.
	//   "REDACTED_CONTACT_DATA" - The organization name (if provided) and limited
	// non-identifying data from `ContactSettings` is available to the public (e.g.
	// country and state). The remaining data is marked as `REDACTED FOR PRIVACY`
	// in the WHOIS database. The actual information redacted depends on the
	// domain. For details, see [the registration privacy
	// article](https://support.google.com/domains/answer/3251242).
	SupportedPrivacy []string `json:"supportedPrivacy,omitempty"`
	// TransferFailureReason: Output only. Deprecated: For more information, see
	// Cloud Domains feature deprecation
	// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
	// The reason the domain transfer failed. Only set for domains in
	// TRANSFER_FAILED state.
	//
	// Possible values:
	//   "TRANSFER_FAILURE_REASON_UNSPECIFIED" - Transfer failure unspecified.
	//   "TRANSFER_FAILURE_REASON_UNKNOWN" - Transfer failed for an unknown reason.
	//   "EMAIL_CONFIRMATION_FAILURE" - An email confirmation sent to the user was
	// rejected or expired.
	//   "DOMAIN_NOT_REGISTERED" - The domain is available for registration.
	//   "DOMAIN_HAS_TRANSFER_LOCK" - The domain has a transfer lock with its
	// current registrar which must be removed prior to transfer.
	//   "INVALID_AUTHORIZATION_CODE" - The authorization code entered is not
	// valid.
	//   "TRANSFER_CANCELLED" - The transfer was cancelled by the domain owner,
	// current registrar, or TLD registry.
	//   "TRANSFER_REJECTED" - The transfer was rejected by the current registrar.
	// Contact the current registrar for more information.
	//   "INVALID_REGISTRANT_EMAIL_ADDRESS" - The registrant email address cannot
	// be parsed from the domain's current public contact data.
	//   "DOMAIN_NOT_ELIGIBLE_FOR_TRANSFER" - The domain is not eligible for
	// transfer due requirements imposed by the current registrar or TLD registry.
	//   "TRANSFER_ALREADY_PENDING" - Another transfer is already pending for this
	// domain. The existing transfer attempt must expire or be cancelled in order
	// to proceed.
	TransferFailureReason string `json:"transferFailureReason,omitempty"`

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

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

// RenewDomainRequest: Request for the `RenewDomain` method.
type RenewDomainRequest struct {
	// ValidateOnly: Optional. When true, only validation is performed, without
	// actually renewing the domain. For more information, see Request validation
	// (https://cloud.google.com/apis/design/design_patterns#request_validation)
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// YearlyPrice: Required. Acknowledgement of the price to renew the domain for
	// one year. To get the price, see Cloud Domains pricing
	// (https://cloud.google.com/domains/pricing). If not provided, the expected
	// price is returned in the error message.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "ValidateOnly") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "ValidateOnly") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// ResetAuthorizationCodeRequest: Request for the `ResetAuthorizationCode`
// method.
type ResetAuthorizationCodeRequest struct {
}

// ResourceRecordSet: A unit of data that is returned by the DNS servers.
type ResourceRecordSet struct {
	// Name: For example, www.example.com.
	Name string `json:"name,omitempty"`
	// RoutingPolicy: Configures dynamic query responses based on either the geo
	// location of the querying user or a weighted round robin based routing
	// policy. A valid `ResourceRecordSet` contains only `rrdata` (for static
	// resolution) or a `routing_policy` (for dynamic resolution).
	RoutingPolicy *RRSetRoutingPolicy `json:"routingPolicy,omitempty"`
	// Rrdata: As defined in RFC 1035 (section 5) and RFC 1034 (section 3.6.1) --
	// see examples.
	Rrdata []string `json:"rrdata,omitempty"`
	// SignatureRrdata: As defined in RFC 4034 (section 3.2).
	SignatureRrdata []string `json:"signatureRrdata,omitempty"`
	// Ttl: Number of seconds that this `ResourceRecordSet` can be cached by
	// resolvers.
	Ttl int64 `json:"ttl,omitempty"`
	// Type: The identifier of a supported record type. See the list of Supported
	// DNS record types.
	Type string `json:"type,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Name") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// RetrieveGoogleDomainsDnsRecordsResponse: Response for the
// `RetrieveGoogleDomainsDnsRecords` method.
type RetrieveGoogleDomainsDnsRecordsResponse struct {
	// NextPageToken: When present, there are more results to retrieve. Set
	// `page_token` to this value on a subsequent call to get the next page of
	// results.
	NextPageToken string `json:"nextPageToken,omitempty"`
	// Rrset: The resource record set resources (DNS Zone records).
	Rrset []*ResourceRecordSet `json:"rrset,omitempty"`

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

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

// RetrieveGoogleDomainsForwardingConfigResponse: Response for the
// `RetrieveGoogleDomainsForwardingConfig` method.
type RetrieveGoogleDomainsForwardingConfigResponse struct {
	// DomainForwardings: The list of domain forwarding configurations. A
	// forwarding configuration might not work correctly if the required DNS
	// records are not present in the domain's authoritative DNS zone.
	DomainForwardings []*DomainForwarding `json:"domainForwardings,omitempty"`
	// EmailForwardings: The list of email forwarding configurations. A forwarding
	// configuration might not work correctly if the required DNS records are not
	// present in the domain's authoritative DNS zone.
	EmailForwardings []*EmailForwarding `json:"emailForwardings,omitempty"`

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

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

// RetrieveImportableDomainsResponse: Deprecated: For more information, see
// Cloud Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Response for the `RetrieveImportableDomains` method.
type RetrieveImportableDomainsResponse struct {
	// Domains: A list of domains that the calling user manages in Google Domains.
	Domains []*Domain `json:"domains,omitempty"`
	// NextPageToken: When present, there are more results to retrieve. Set
	// `page_token` to this value on a subsequent call to get the next page of
	// results.
	NextPageToken string `json:"nextPageToken,omitempty"`

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

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

// RetrieveRegisterParametersResponse: Response for the
// `RetrieveRegisterParameters` method.
type RetrieveRegisterParametersResponse struct {
	// RegisterParameters: Parameters to use when calling the `RegisterDomain`
	// method.
	RegisterParameters *RegisterParameters `json:"registerParameters,omitempty"`

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

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

// RetrieveTransferParametersResponse: Deprecated: For more information, see
// Cloud Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Response for the `RetrieveTransferParameters` method.
type RetrieveTransferParametersResponse struct {
	// TransferParameters: Parameters to use when calling the `TransferDomain`
	// method.
	TransferParameters *TransferParameters `json:"transferParameters,omitempty"`

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

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

// SearchDomainsResponse: Response for the `SearchDomains` method.
type SearchDomainsResponse struct {
	// RegisterParameters: Results of the domain name search.
	RegisterParameters []*RegisterParameters `json:"registerParameters,omitempty"`

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

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

// SetIamPolicyRequest: Request message for `SetIamPolicy` method.
type SetIamPolicyRequest struct {
	// Policy: REQUIRED: The complete policy to be applied to the `resource`. The
	// size of the policy is limited to a few 10s of KB. An empty policy is a valid
	// policy but certain Google Cloud services (such as Projects) might reject
	// them.
	Policy *Policy `json:"policy,omitempty"`
	// UpdateMask: OPTIONAL: A FieldMask specifying which fields of the policy to
	// modify. Only the fields in the mask will be modified. If no mask is
	// provided, the following default mask is used: `paths: "bindings, etag"
	UpdateMask string `json:"updateMask,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Policy") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Policy") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// Status: The `Status` type defines a logical error model that is suitable for
// different programming environments, including REST APIs and RPC APIs. It is
// used by gRPC (https://github.com/grpc). Each `Status` message contains three
// pieces of data: error code, error message, and error details. You can find
// out more about this error model and how to work with it in the API Design
// Guide (https://cloud.google.com/apis/design/errors).
type Status struct {
	// Code: The status code, which should be an enum value of google.rpc.Code.
	Code int64 `json:"code,omitempty"`
	// Details: A list of messages that carry the error details. There is a common
	// set of message types for APIs to use.
	Details []googleapi.RawMessage `json:"details,omitempty"`
	// Message: A developer-facing error message, which should be in English. Any
	// user-facing error message should be localized and sent in the
	// google.rpc.Status.details field, or localized by the client.
	Message string `json:"message,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Code") to unconditionally
	// include in API requests. By default, fields with empty or default values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Code") to include in API requests
	// with the JSON null value. By default, fields with empty values are omitted
	// from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// TestIamPermissionsRequest: Request message for `TestIamPermissions` method.
type TestIamPermissionsRequest struct {
	// Permissions: The set of permissions to check for the `resource`. Permissions
	// with wildcards (such as `*` or `storage.*`) are not allowed. For more
	// information see IAM Overview
	// (https://cloud.google.com/iam/docs/overview#permissions).
	Permissions []string `json:"permissions,omitempty"`
	// ForceSendFields is a list of field names (e.g. "Permissions") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "Permissions") to include in API
	// requests with the JSON null value. By default, fields with empty values are
	// omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// TestIamPermissionsResponse: Response message for `TestIamPermissions`
// method.
type TestIamPermissionsResponse struct {
	// Permissions: A subset of `TestPermissionsRequest.permissions` that the
	// caller is allowed.
	Permissions []string `json:"permissions,omitempty"`

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

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

// TransferDomainRequest: Deprecated: For more information, see Cloud Domains
// feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Request for the `TransferDomain` method.
type TransferDomainRequest struct {
	// AuthorizationCode: The domain's transfer authorization code. You can obtain
	// this from the domain's current registrar.
	AuthorizationCode *AuthorizationCode `json:"authorizationCode,omitempty"`
	// ContactNotices: The list of contact notices that you acknowledge. The
	// notices needed here depend on the values specified in
	// `registration.contact_settings`.
	//
	// Possible values:
	//   "CONTACT_NOTICE_UNSPECIFIED" - The notice is undefined.
	//   "PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT" - Required when setting the
	// `privacy` field of `ContactSettings` to `PUBLIC_CONTACT_DATA`, which exposes
	// contact data publicly.
	ContactNotices []string `json:"contactNotices,omitempty"`
	// Registration: Required. The complete `Registration` resource to be created.
	// You can leave `registration.dns_settings` unset to import the domain's
	// current DNS configuration from its current registrar. Use this option only
	// if you are sure that the domain's current DNS service does not cease upon
	// transfer, as is often the case for DNS services provided for free by the
	// registrar.
	Registration *Registration `json:"registration,omitempty"`
	// ValidateOnly: Validate the request without actually transferring the domain.
	ValidateOnly bool `json:"validateOnly,omitempty"`
	// YearlyPrice: Required. Acknowledgement of the price to transfer or renew the
	// domain for one year. Call `RetrieveTransferParameters` to obtain the price,
	// which you must acknowledge.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "AuthorizationCode") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "AuthorizationCode") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

// TransferParameters: Deprecated: For more information, see Cloud Domains
// feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations).
// Parameters required to transfer a domain from another registrar.
type TransferParameters struct {
	// CurrentRegistrar: The registrar that currently manages the domain.
	CurrentRegistrar string `json:"currentRegistrar,omitempty"`
	// CurrentRegistrarUri: The URL of the registrar that currently manages the
	// domain.
	CurrentRegistrarUri string `json:"currentRegistrarUri,omitempty"`
	// DomainName: The domain name. Unicode domain names are expressed in Punycode
	// format.
	DomainName string `json:"domainName,omitempty"`
	// NameServers: The name servers that currently store the configuration of the
	// domain.
	NameServers []string `json:"nameServers,omitempty"`
	// SupportedPrivacy: Contact privacy options that the domain supports.
	//
	// Possible values:
	//   "CONTACT_PRIVACY_UNSPECIFIED" - The contact privacy settings are
	// undefined.
	//   "PUBLIC_CONTACT_DATA" - All the data from `ContactSettings` is publicly
	// available. When setting this option, you must also provide a
	// `PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT` in the `contact_notices` field of the
	// request.
	//   "PRIVATE_CONTACT_DATA" - Deprecated: For more information, see [Cloud
	// Domains feature
	// deprecation](https://cloud.google.com/domains/docs/deprecations/feature-depre
	// cations). None of the data from `ContactSettings` is publicly available.
	// Instead, proxy contact data is published for your domain. Email sent to the
	// proxy email address is forwarded to the registrant's email address. Cloud
	// Domains provides this privacy proxy service at no additional cost.
	//   "REDACTED_CONTACT_DATA" - The organization name (if provided) and limited
	// non-identifying data from `ContactSettings` is available to the public (e.g.
	// country and state). The remaining data is marked as `REDACTED FOR PRIVACY`
	// in the WHOIS database. The actual information redacted depends on the
	// domain. For details, see [the registration privacy
	// article](https://support.google.com/domains/answer/3251242).
	SupportedPrivacy []string `json:"supportedPrivacy,omitempty"`
	// TransferLockState: Indicates whether the domain is protected by a transfer
	// lock. For a transfer to succeed, this must show `UNLOCKED`. To unlock a
	// domain, go to its current registrar.
	//
	// Possible values:
	//   "TRANSFER_LOCK_STATE_UNSPECIFIED" - The state is unspecified.
	//   "UNLOCKED" - The domain is unlocked and can be transferred to another
	// registrar.
	//   "LOCKED" - The domain is locked and cannot be transferred to another
	// registrar.
	TransferLockState string `json:"transferLockState,omitempty"`
	// YearlyPrice: Price to transfer or renew the domain for one year.
	YearlyPrice *Money `json:"yearlyPrice,omitempty"`
	// ForceSendFields is a list of field names (e.g. "CurrentRegistrar") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "CurrentRegistrar") to include in
	// API requests with the JSON null value. By default, fields with empty values
	// are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

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

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

// WrrPolicyItem: A routing block which contains the routing information for
// one WRR item.
type WrrPolicyItem struct {
	// HealthCheckedTargets: Endpoints that are health checked before making the
	// routing decision. The unhealthy endpoints are omitted from the result. If
	// all endpoints within a bucket are unhealthy, we choose a different bucket
	// (sampled with respect to its weight) for responding. If DNSSEC is enabled
	// for this zone, only one of `rrdata` or `health_checked_targets` can be set.
	HealthCheckedTargets *HealthCheckTargets `json:"healthCheckedTargets,omitempty"`
	Rrdata               []string            `json:"rrdata,omitempty"`
	// SignatureRrdata: DNSSEC generated signatures for all the `rrdata` within
	// this item. When using health-checked targets for DNSSEC-enabled zones, you
	// can only use at most one health-checked IP address per item.
	SignatureRrdata []string `json:"signatureRrdata,omitempty"`
	// Weight: The weight corresponding to this `WrrPolicyItem` object. When
	// multiple `WrrPolicyItem` objects are configured, the probability of
	// returning an `WrrPolicyItem` object's data is proportional to its weight
	// relative to the sum of weights configured for all items. This weight must be
	// non-negative.
	Weight float64 `json:"weight,omitempty"`
	// ForceSendFields is a list of field names (e.g. "HealthCheckedTargets") to
	// unconditionally include in API requests. By default, fields with empty or
	// default values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
	// details.
	ForceSendFields []string `json:"-"`
	// NullFields is a list of field names (e.g. "HealthCheckedTargets") to include
	// in API requests with the JSON null value. By default, fields with empty
	// values are omitted from API requests. See
	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
	NullFields []string `json:"-"`
}

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

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

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

// Get: Gets information about a location.
//
// - name: Resource name for the location.
func (r *ProjectsLocationsService) Get(name string) *ProjectsLocationsGetCall {
	c := &ProjectsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *Location.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsGetCall) Do(opts ...googleapi.CallOption) (*Location, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Location{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// List: Lists information about the supported locations for this service. This
// method lists locations based on the resource scope provided in the
// ListLocationsRequest.name field: * **Global locations**: If `name` is empty,
// the method lists the public locations available to all projects. *
// **Project-specific locations**: If `name` follows the format
// `projects/{project}`, the method lists locations visible to that specific
// project. This includes public, private, or other project-specific locations
// enabled for the project. For gRPC and client library implementations, the
// resource name is passed as the `name` field. For direct service calls, the
// resource name is incorporated into the request path based on the specific
// service implementation and version.
//
// - name: The resource that owns the locations collection, if applicable.
func (r *ProjectsLocationsService) List(name string) *ProjectsLocationsListCall {
	c := &ProjectsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// ExtraLocationTypes sets the optional parameter "extraLocationTypes": Do not
// use this field unless explicitly documented otherwise. This is primarily for
// internal usage.
func (c *ProjectsLocationsListCall) ExtraLocationTypes(extraLocationTypes ...string) *ProjectsLocationsListCall {
	c.urlParams_.SetMulti("extraLocationTypes", append([]string{}, extraLocationTypes...))
	return c
}

// Filter sets the optional parameter "filter": A filter to narrow down results
// to a preferred subset. The filtering language accepts strings like
// "displayName=tokyo", and is documented in more detail in AIP-160
// (https://google.aip.dev/160).
func (c *ProjectsLocationsListCall) Filter(filter string) *ProjectsLocationsListCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": The maximum number of
// results to return. If not set, the service selects a default.
func (c *ProjectsLocationsListCall) PageSize(pageSize int64) *ProjectsLocationsListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": A page token received
// from the `next_page_token` field in the response. Send that page token to
// receive the subsequent page.
func (c *ProjectsLocationsListCall) PageToken(pageToken string) *ProjectsLocationsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListLocationsResponse.ServerResponse.Header or (if a response was returned
// at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *ProjectsLocationsListCall) Do(opts ...googleapi.CallOption) (*ListLocationsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListLocationsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsLocationsListCall) Pages(ctx context.Context, f func(*ListLocationsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

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

// Get: Gets the latest state of a long-running operation. Clients can use this
// method to poll the operation result at intervals as recommended by the API
// service.
//
// - name: The name of the operation resource.
func (r *ProjectsLocationsOperationsService) Get(name string) *ProjectsLocationsOperationsGetCall {
	c := &ProjectsLocationsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.operations.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.operations.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// List: Lists operations that match the specified filter in the request. If
// the server doesn't support this method, it returns `UNIMPLEMENTED`.
//
// - name: The name of the operation's parent resource.
func (r *ProjectsLocationsOperationsService) List(name string) *ProjectsLocationsOperationsListCall {
	c := &ProjectsLocationsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

// Filter sets the optional parameter "filter": The standard list filter.
func (c *ProjectsLocationsOperationsListCall) Filter(filter string) *ProjectsLocationsOperationsListCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": The standard list page
// size.
func (c *ProjectsLocationsOperationsListCall) PageSize(pageSize int64) *ProjectsLocationsOperationsListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": The standard list page
// token.
func (c *ProjectsLocationsOperationsListCall) PageToken(pageToken string) *ProjectsLocationsOperationsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

// ReturnPartialSuccess sets the optional parameter "returnPartialSuccess":
// When set to `true`, operations that are reachable are returned as normal,
// and those that are unreachable are returned in the
// ListOperationsResponse.unreachable field. This can only be `true` when
// reading across collections. For example, when `parent` is set to
// "projects/example/locations/-". This field is not supported by default and
// will result in an `UNIMPLEMENTED` error if set unless explicitly documented
// otherwise in service or product specific documentation.
func (c *ProjectsLocationsOperationsListCall) ReturnPartialSuccess(returnPartialSuccess bool) *ProjectsLocationsOperationsListCall {
	c.urlParams_.Set("returnPartialSuccess", fmt.Sprint(returnPartialSuccess))
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsOperationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsOperationsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.operations.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListOperationsResponse.ServerResponse.Header or (if a response was returned
// at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *ProjectsLocationsOperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListOperationsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.operations.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsLocationsOperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type ProjectsLocationsRegistrationsConfigureContactSettingsCall struct {
	s                               *Service
	registration                    string
	configurecontactsettingsrequest *ConfigureContactSettingsRequest
	urlParams_                      gensupport.URLParams
	ctx_                            context.Context
	header_                         http.Header
}

// ConfigureContactSettings: Updates a `Registration`'s contact settings. Some
// changes require confirmation by the domain's registrant contact . Caution:
// Please consider carefully any changes to contact privacy settings when
// changing from `REDACTED_CONTACT_DATA` to `PUBLIC_CONTACT_DATA.` There may be
// a delay in reflecting updates you make to registrant contact information
// such that any changes you make to contact privacy (including from
// `REDACTED_CONTACT_DATA` to `PUBLIC_CONTACT_DATA`) will be applied without
// delay but changes to registrant contact information may take a limited time
// to be publicized. This means that changes to contact privacy from
// `REDACTED_CONTACT_DATA` to `PUBLIC_CONTACT_DATA` may make the previous
// registrant contact data public until the modified registrant contact details
// are published.
//
//   - registration: The name of the `Registration` whose contact settings are
//     being updated, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) ConfigureContactSettings(registration string, configurecontactsettingsrequest *ConfigureContactSettingsRequest) *ProjectsLocationsRegistrationsConfigureContactSettingsCall {
	c := &ProjectsLocationsRegistrationsConfigureContactSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.configurecontactsettingsrequest = configurecontactsettingsrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsConfigureContactSettingsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.configurecontactsettingsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:configureContactSettings")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureContactSettings", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.configureContactSettings" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsConfigureContactSettingsCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureContactSettings", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsConfigureDnsSettingsCall struct {
	s                           *Service
	registration                string
	configurednssettingsrequest *ConfigureDnsSettingsRequest
	urlParams_                  gensupport.URLParams
	ctx_                        context.Context
	header_                     http.Header
}

// ConfigureDnsSettings: Updates a `Registration`'s DNS settings.
//
//   - registration: The name of the `Registration` whose DNS settings are being
//     updated, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) ConfigureDnsSettings(registration string, configurednssettingsrequest *ConfigureDnsSettingsRequest) *ProjectsLocationsRegistrationsConfigureDnsSettingsCall {
	c := &ProjectsLocationsRegistrationsConfigureDnsSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.configurednssettingsrequest = configurednssettingsrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsConfigureDnsSettingsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.configurednssettingsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:configureDnsSettings")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureDnsSettings", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.configureDnsSettings" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsConfigureDnsSettingsCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureDnsSettings", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsConfigureManagementSettingsCall struct {
	s                                  *Service
	registration                       string
	configuremanagementsettingsrequest *ConfigureManagementSettingsRequest
	urlParams_                         gensupport.URLParams
	ctx_                               context.Context
	header_                            http.Header
}

// ConfigureManagementSettings: Updates a `Registration`'s management settings.
//
//   - registration: The name of the `Registration` whose management settings are
//     being updated, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) ConfigureManagementSettings(registration string, configuremanagementsettingsrequest *ConfigureManagementSettingsRequest) *ProjectsLocationsRegistrationsConfigureManagementSettingsCall {
	c := &ProjectsLocationsRegistrationsConfigureManagementSettingsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.configuremanagementsettingsrequest = configuremanagementsettingsrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsConfigureManagementSettingsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.configuremanagementsettingsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:configureManagementSettings")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureManagementSettings", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.configureManagementSettings" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsConfigureManagementSettingsCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.configureManagementSettings", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// Delete: Deletes a `Registration` resource. This method works on any
// `Registration` resource using Subscription or Commitment billing
// (/domains/pricing#billing-models), provided that the resource was created at
// least 1 day in the past. When an active registration is successfully
// deleted, you can continue to use the domain in Google Domains
// (https://domains.google/) until it expires. The calling user becomes the
// domain's sole owner in Google Domains, and permissions for the domain are
// subsequently managed there. The domain does not renew automatically unless
// the new owner sets up billing in Google Domains. After January 2024 you will
// only be able to delete `Registration` resources when `state` is one of:
// `EXPORTED`, `EXPIRED`,`REGISTRATION_FAILED` or `TRANSFER_FAILED`. See Cloud
// Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// for more details.
//
//   - name: The name of the `Registration` to delete, in the format
//     `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) Delete(name string) *ProjectsLocationsRegistrationsDeleteCall {
	c := &ProjectsLocationsRegistrationsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsDeleteCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("DELETE", urls, nil)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.delete", "request", internallog.HTTPRequest(req, nil))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.delete" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsDeleteCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.delete", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsExportCall struct {
	s                         *Service
	name                      string
	exportregistrationrequest *ExportRegistrationRequest
	urlParams_                gensupport.URLParams
	ctx_                      context.Context
	header_                   http.Header
}

// Export: Deprecated: For more information, see Cloud Domains feature
// deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// Exports a `Registration` resource, such that it is no longer managed by
// Cloud Domains. When an active domain is successfully exported, you can
// continue to use the domain in Google Domains (https://domains.google/) until
// it expires. The calling user becomes the domain's sole owner in Google
// Domains, and permissions for the domain are subsequently managed there. The
// domain does not renew automatically unless the new owner sets up billing in
// Google Domains.
//
//   - name: The name of the `Registration` to export, in the format
//     `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) Export(name string, exportregistrationrequest *ExportRegistrationRequest) *ProjectsLocationsRegistrationsExportCall {
	c := &ProjectsLocationsRegistrationsExportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.exportregistrationrequest = exportregistrationrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsExportCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.exportregistrationrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}:export")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.export", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.export" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsExportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.export", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// Get: Gets the details of a `Registration` resource.
//
//   - name: The name of the `Registration` to get, in the format
//     `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) Get(name string) *ProjectsLocationsRegistrationsGetCall {
	c := &ProjectsLocationsRegistrationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsGetCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsGetCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.get" call.
// Any non-2xx status code is an error. Response headers are in either
// *Registration.ServerResponse.Header or (if a response was returned at all)
// in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsGetCall) Do(opts ...googleapi.CallOption) (*Registration, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Registration{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.get", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// GetIamPolicy: Gets the access control policy for a resource. Returns an
// empty policy if the resource exists and does not have a policy set.
//
//   - resource: REQUIRED: The resource for which the policy is being requested.
//     See Resource names (https://cloud.google.com/apis/design/resource_names)
//     for the appropriate value for this field.
func (r *ProjectsLocationsRegistrationsService) GetIamPolicy(resource string) *ProjectsLocationsRegistrationsGetIamPolicyCall {
	c := &ProjectsLocationsRegistrationsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.resource = resource
	return c
}

// OptionsRequestedPolicyVersion sets the optional parameter
// "options.requestedPolicyVersion": The maximum policy version that will be
// used to format the policy. Valid values are 0, 1, and 3. Requests specifying
// an invalid value will be rejected. Requests for policies with any
// conditional role bindings must specify version 3. Policies with no
// conditional role bindings may specify any valid value or leave the field
// unset. The policy in the response might use the policy version that you
// specified, or it might use a lower policy version. For example, if you
// specify version 3, but the policy has no conditional role bindings, the
// response uses version 1. To learn which resources support conditions in
// their IAM policies, see the IAM documentation
// (https://cloud.google.com/iam/help/conditions/resource-policies).
func (c *ProjectsLocationsRegistrationsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsLocationsRegistrationsGetIamPolicyCall {
	c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsGetIamPolicyCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.getIamPolicy" call.
// Any non-2xx status code is an error. Response headers are in either
// *Policy.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Policy{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.getIamPolicy", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsImportCall struct {
	s                   *Service
	parent              string
	importdomainrequest *ImportDomainRequest
	urlParams_          gensupport.URLParams
	ctx_                context.Context
	header_             http.Header
}

// Import: Deprecated: For more information, see Cloud Domains feature
// deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// Imports a domain name from Google Domains (https://domains.google/) for use
// in Cloud Domains. To transfer a domain from another registrar, use the
// `TransferDomain` method instead. Since individual users can own domains in
// Google Domains, the calling user must have ownership permission on the
// domain.
//
//   - parent: The parent resource of the Registration. Must be in the format
//     `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) Import(parent string, importdomainrequest *ImportDomainRequest) *ProjectsLocationsRegistrationsImportCall {
	c := &ProjectsLocationsRegistrationsImportCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.importdomainrequest = importdomainrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsImportCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.importdomainrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/registrations:import")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.import", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.import" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsImportCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.import", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsInitiatePushTransferCall struct {
	s                           *Service
	registration                string
	initiatepushtransferrequest *InitiatePushTransferRequest
	urlParams_                  gensupport.URLParams
	ctx_                        context.Context
	header_                     http.Header
}

// InitiatePushTransfer: Initiates the `Push Transfer` process to transfer the
// domain to another registrar. The process might complete instantly or might
// require confirmation or additional work. Check the emails sent to the email
// address of the registrant. The process is aborted after a timeout if it's
// not completed. This method is only supported for domains that have the
// `REQUIRE_PUSH_TRANSFER` property in the list of `domain_properties`. The
// domain must also be unlocked before it can be transferred to a different
// registrar. For more information, see Transfer a registered domain to another
// registrar
// (https://cloud.google.com/domains/docs/transfer-domain-to-another-registrar).
//
//   - registration: The name of the `Registration` for which the push transfer
//     is initiated, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) InitiatePushTransfer(registration string, initiatepushtransferrequest *InitiatePushTransferRequest) *ProjectsLocationsRegistrationsInitiatePushTransferCall {
	c := &ProjectsLocationsRegistrationsInitiatePushTransferCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.initiatepushtransferrequest = initiatepushtransferrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsInitiatePushTransferCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.initiatepushtransferrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:initiatePushTransfer")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.initiatePushTransfer", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.initiatePushTransfer" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsInitiatePushTransferCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.initiatePushTransfer", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// List: Lists the `Registration` resources in a project.
//
//   - parent: The project and location from which to list `Registration`s,
//     specified in the format `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) List(parent string) *ProjectsLocationsRegistrationsListCall {
	c := &ProjectsLocationsRegistrationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	return c
}

// Filter sets the optional parameter "filter": Filter expression to restrict
// the `Registration`s returned. The expression must specify the field name, a
// comparison operator, and the value that you want to use for filtering. The
// value must be a string, a number, a boolean, or an enum value. The
// comparison operator should be one of =, !=, >, <, >=, <=, or : for prefix or
// wildcard matches. For example, to filter to a specific domain name, use an
// expression like `domainName="example.com". You can also check for the
// existence of a field; for example, to find domains using custom DNS
// settings, use an expression like `dnsSettings.customDns:*`. You can also
// create compound filters by combining expressions with the `AND` and `OR`
// operators. For example, to find domains that are suspended or have specific
// issues flagged, use an expression like `(state=SUSPENDED) OR (issue:*)`.
func (c *ProjectsLocationsRegistrationsListCall) Filter(filter string) *ProjectsLocationsRegistrationsListCall {
	c.urlParams_.Set("filter", filter)
	return c
}

// PageSize sets the optional parameter "pageSize": Maximum number of results
// to return.
func (c *ProjectsLocationsRegistrationsListCall) PageSize(pageSize int64) *ProjectsLocationsRegistrationsListCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": When set to the
// `next_page_token` from a prior response, provides the next page of results.
func (c *ProjectsLocationsRegistrationsListCall) PageToken(pageToken string) *ProjectsLocationsRegistrationsListCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsListCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsListCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.list" call.
// Any non-2xx status code is an error. Response headers are in either
// *ListRegistrationsResponse.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsListCall) Do(opts ...googleapi.CallOption) (*ListRegistrationsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &ListRegistrationsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.list", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsLocationsRegistrationsListCall) Pages(ctx context.Context, f func(*ListRegistrationsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

type ProjectsLocationsRegistrationsPatchCall struct {
	s            *Service
	name         string
	registration *Registration
	urlParams_   gensupport.URLParams
	ctx_         context.Context
	header_      http.Header
}

// Patch: Updates select fields of a `Registration` resource, notably `labels`.
// To update other fields, use the appropriate custom update method: * To
// update management settings, see `ConfigureManagementSettings` * To update
// DNS configuration, see `ConfigureDnsSettings` * To update contact
// information, see `ConfigureContactSettings`
//
//   - name: Output only. Name of the `Registration` resource, in the format
//     `projects/*/locations/*/registrations/`.
func (r *ProjectsLocationsRegistrationsService) Patch(name string, registration *Registration) *ProjectsLocationsRegistrationsPatchCall {
	c := &ProjectsLocationsRegistrationsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.name = name
	c.registration = registration
	return c
}

// UpdateMask sets the optional parameter "updateMask": Required. The field
// mask describing which fields to update as a comma-separated list. For
// example, if only the labels are being updated, the `update_mask` is
// "labels".
func (c *ProjectsLocationsRegistrationsPatchCall) UpdateMask(updateMask string) *ProjectsLocationsRegistrationsPatchCall {
	c.urlParams_.Set("updateMask", updateMask)
	return c
}

// ValidateOnly sets the optional parameter "validateOnly": If set, validates
// the request without actually updating the registration.
func (c *ProjectsLocationsRegistrationsPatchCall) ValidateOnly(validateOnly bool) *ProjectsLocationsRegistrationsPatchCall {
	c.urlParams_.Set("validateOnly", fmt.Sprint(validateOnly))
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsPatchCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.registration)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("PATCH", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"name": c.name,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.patch", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.patch" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsPatchCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.patch", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsRegisterCall struct {
	s                     *Service
	parent                string
	registerdomainrequest *RegisterDomainRequest
	urlParams_            gensupport.URLParams
	ctx_                  context.Context
	header_               http.Header
}

// Register: Registers a new domain name and creates a corresponding
// `Registration` resource. Call `RetrieveRegisterParameters` first to check
// availability of the domain name and determine parameters like price that are
// needed to build a call to this method. A successful call creates a
// `Registration` resource in state `REGISTRATION_PENDING`, which resolves to
// `ACTIVE` within 1-2 minutes, indicating that the domain was successfully
// registered. If the resource ends up in state `REGISTRATION_FAILED`, it
// indicates that the domain was not registered successfully, and you can
// safely delete the resource and retry registration.
//
//   - parent: The parent resource of the `Registration`. Must be in the format
//     `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) Register(parent string, registerdomainrequest *RegisterDomainRequest) *ProjectsLocationsRegistrationsRegisterCall {
	c := &ProjectsLocationsRegistrationsRegisterCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.registerdomainrequest = registerdomainrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsRegisterCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.registerdomainrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/registrations:register")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.register", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.register" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRegisterCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.register", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsRenewDomainCall struct {
	s                  *Service
	registration       string
	renewdomainrequest *RenewDomainRequest
	urlParams_         gensupport.URLParams
	ctx_               context.Context
	header_            http.Header
}

// RenewDomain: Renews a recently expired domain. This method can only be
// called on domains that expired in the previous 30 days. After the renewal,
// the new expiration time of the domain is one year after the old expiration
// time and you are charged a `yearly_price` for the renewal.
//
//   - registration: The name of the `Registration` whish is being renewed, in
//     the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) RenewDomain(registration string, renewdomainrequest *RenewDomainRequest) *ProjectsLocationsRegistrationsRenewDomainCall {
	c := &ProjectsLocationsRegistrationsRenewDomainCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.renewdomainrequest = renewdomainrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsRenewDomainCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.renewdomainrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:renewDomain")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.renewDomain", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.renewDomain" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRenewDomainCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.renewDomain", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsResetAuthorizationCodeCall struct {
	s                             *Service
	registration                  string
	resetauthorizationcoderequest *ResetAuthorizationCodeRequest
	urlParams_                    gensupport.URLParams
	ctx_                          context.Context
	header_                       http.Header
}

// ResetAuthorizationCode: Resets the authorization code of the `Registration`
// to a new random string. You can call this method only after 60 days have
// elapsed since the initial domain registration. Domains that have the
// `REQUIRE_PUSH_TRANSFER` property in the list of `domain_properties` don't
// support authorization codes and must use the `InitiatePushTransfer` method
// to initiate the process to transfer the domain to a different registrar.
//
//   - registration: The name of the `Registration` whose authorization code is
//     being reset, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) ResetAuthorizationCode(registration string, resetauthorizationcoderequest *ResetAuthorizationCodeRequest) *ProjectsLocationsRegistrationsResetAuthorizationCodeCall {
	c := &ProjectsLocationsRegistrationsResetAuthorizationCodeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	c.resetauthorizationcoderequest = resetauthorizationcoderequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsResetAuthorizationCodeCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.resetauthorizationcoderequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+registration}:resetAuthorizationCode")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"registration": c.registration,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.resetAuthorizationCode", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.resetAuthorizationCode" call.
// Any non-2xx status code is an error. Response headers are in either
// *AuthorizationCode.ServerResponse.Header or (if a response was returned at
// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *ProjectsLocationsRegistrationsResetAuthorizationCodeCall) Do(opts ...googleapi.CallOption) (*AuthorizationCode, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &AuthorizationCode{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.resetAuthorizationCode", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// RetrieveAuthorizationCode: Gets the authorization code of the `Registration`
// for the purpose of transferring the domain to another registrar. You can
// call this method only after 60 days have elapsed since the initial domain
// registration. Domains that have the `REQUIRE_PUSH_TRANSFER` property in the
// list of `domain_properties` don't support authorization codes and must use
// the `InitiatePushTransfer` method to initiate the process to transfer the
// domain to a different registrar.
//
//   - registration: The name of the `Registration` whose authorization code is
//     being retrieved, in the format `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveAuthorizationCode(registration string) *ProjectsLocationsRegistrationsRetrieveAuthorizationCodeCall {
	c := &ProjectsLocationsRegistrationsRetrieveAuthorizationCodeCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveAuthorizationCodeCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveAuthorizationCodeCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveAuthorizationCode" call.
// Any non-2xx status code is an error. Response headers are in either
// *AuthorizationCode.ServerResponse.Header or (if a response was returned at
// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *ProjectsLocationsRegistrationsRetrieveAuthorizationCodeCall) Do(opts ...googleapi.CallOption) (*AuthorizationCode, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &AuthorizationCode{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveAuthorizationCode", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// RetrieveGoogleDomainsDnsRecords: Lists the DNS records from the Google
// Domains DNS zone for domains that use the deprecated `google_domains_dns` in
// the `Registration`'s `dns_settings`.
//
//   - registration: The name of the `Registration` whose Google Domains DNS
//     records details you are retrieving, in the format
//     `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveGoogleDomainsDnsRecords(registration string) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall {
	c := &ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	return c
}

// PageSize sets the optional parameter "pageSize": Maximum number of results
// to return.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall) PageSize(pageSize int64) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": When set to the
// `next_page_token` from a prior response, provides the next page of results.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall) PageToken(pageToken string) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveGoogleDomainsDnsRecords" call.
// Any non-2xx status code is an error. Response headers are in either
// *RetrieveGoogleDomainsDnsRecordsResponse.ServerResponse.Header or (if a
// response was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall) Do(opts ...googleapi.CallOption) (*RetrieveGoogleDomainsDnsRecordsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RetrieveGoogleDomainsDnsRecordsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveGoogleDomainsDnsRecords", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsCall) Pages(ctx context.Context, f func(*RetrieveGoogleDomainsDnsRecordsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

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

// RetrieveGoogleDomainsForwardingConfig: Lists the deprecated domain and email
// forwarding configurations you set up in the deprecated Google Domains UI.
// The configuration is present only for domains with the
// `google_domains_redirects_data_available` set to `true` in the
// `Registration`'s `dns_settings`. A forwarding configuration might not work
// correctly if required DNS records are not present in the domain's
// authoritative DNS Zone.
//
//   - registration: The name of the `Registration` whose Google Domains
//     forwarding configuration details are being retrieved, in the format
//     `projects/*/locations/*/registrations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveGoogleDomainsForwardingConfig(registration string) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigCall {
	c := &ProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.registration = registration
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveGoogleDomainsForwardingConfig" call.
// Any non-2xx status code is an error. Response headers are in either
// *RetrieveGoogleDomainsForwardingConfigResponse.ServerResponse.Header or (if
// a response was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigCall) Do(opts ...googleapi.CallOption) (*RetrieveGoogleDomainsForwardingConfigResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RetrieveGoogleDomainsForwardingConfigResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveGoogleDomainsForwardingConfig", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// RetrieveImportableDomains: Deprecated: For more information, see Cloud
// Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// Lists domain names from Google Domains (https://domains.google/) that can be
// imported to Cloud Domains using the `ImportDomain` method. Since individual
// users can own domains in Google Domains, the list of domains returned
// depends on the individual user making the call. Domains already managed by
// Cloud Domains are not returned.
//
// - location: The location. Must be in the format `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveImportableDomains(location string) *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall {
	c := &ProjectsLocationsRegistrationsRetrieveImportableDomainsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.location = location
	return c
}

// PageSize sets the optional parameter "pageSize": Maximum number of results
// to return.
func (c *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall) PageSize(pageSize int64) *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall {
	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
	return c
}

// PageToken sets the optional parameter "pageToken": When set to the
// `next_page_token` from a prior response, provides the next page of results.
func (c *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall) PageToken(pageToken string) *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall {
	c.urlParams_.Set("pageToken", pageToken)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveImportableDomains" call.
// Any non-2xx status code is an error. Response headers are in either
// *RetrieveImportableDomainsResponse.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall) Do(opts ...googleapi.CallOption) (*RetrieveImportableDomainsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RetrieveImportableDomainsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveImportableDomains", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

// Pages invokes f for each page of results.
// A non-nil error returned from f will halt the iteration.
// The provided context supersedes any context provided to the Context method.
func (c *ProjectsLocationsRegistrationsRetrieveImportableDomainsCall) Pages(ctx context.Context, f func(*RetrieveImportableDomainsResponse) error) error {
	c.ctx_ = ctx
	defer c.PageToken(c.urlParams_.Get("pageToken"))
	for {
		x, err := c.Do()
		if err != nil {
			return err
		}
		if err := f(x); err != nil {
			return err
		}
		if x.NextPageToken == "" {
			return nil
		}
		c.PageToken(x.NextPageToken)
	}
}

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

// RetrieveRegisterParameters: Gets parameters needed to register a new domain
// name, including price and up-to-date availability. Use the returned values
// to call `RegisterDomain`.
//
// - location: The location. Must be in the format `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveRegisterParameters(location string) *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall {
	c := &ProjectsLocationsRegistrationsRetrieveRegisterParametersCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.location = location
	return c
}

// DomainName sets the optional parameter "domainName": Required. The domain
// name. Unicode domain names must be expressed in Punycode format.
func (c *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall) DomainName(domainName string) *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall {
	c.urlParams_.Set("domainName", domainName)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveRegisterParameters" call.
// Any non-2xx status code is an error. Response headers are in either
// *RetrieveRegisterParametersResponse.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRetrieveRegisterParametersCall) Do(opts ...googleapi.CallOption) (*RetrieveRegisterParametersResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RetrieveRegisterParametersResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveRegisterParameters", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// RetrieveTransferParameters: Deprecated: For more information, see Cloud
// Domains feature deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// Gets parameters needed to transfer a domain name from another registrar to
// Cloud Domains. For domains already managed by Google Domains
// (https://domains.google/), use `ImportDomain` instead. Use the returned
// values to call `TransferDomain`.
//
// - location: The location. Must be in the format `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) RetrieveTransferParameters(location string) *ProjectsLocationsRegistrationsRetrieveTransferParametersCall {
	c := &ProjectsLocationsRegistrationsRetrieveTransferParametersCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.location = location
	return c
}

// DomainName sets the optional parameter "domainName": Required. The domain
// name. Unicode domain names must be expressed in Punycode format.
func (c *ProjectsLocationsRegistrationsRetrieveTransferParametersCall) DomainName(domainName string) *ProjectsLocationsRegistrationsRetrieveTransferParametersCall {
	c.urlParams_.Set("domainName", domainName)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsRetrieveTransferParametersCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsRetrieveTransferParametersCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.retrieveTransferParameters" call.
// Any non-2xx status code is an error. Response headers are in either
// *RetrieveTransferParametersResponse.ServerResponse.Header or (if a response
// was returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsRetrieveTransferParametersCall) Do(opts ...googleapi.CallOption) (*RetrieveTransferParametersResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &RetrieveTransferParametersResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.retrieveTransferParameters", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

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

// SearchDomains: Searches for available domain names similar to the provided
// query. Availability results from this method are approximate; call
// `RetrieveRegisterParameters` on a domain before registering to confirm
// availability.
//
// - location: The location. Must be in the format `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) SearchDomains(location string) *ProjectsLocationsRegistrationsSearchDomainsCall {
	c := &ProjectsLocationsRegistrationsSearchDomainsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.location = location
	return c
}

// Query sets the optional parameter "query": Required. String used to search
// for available domain names.
func (c *ProjectsLocationsRegistrationsSearchDomainsCall) Query(query string) *ProjectsLocationsRegistrationsSearchDomainsCall {
	c.urlParams_.Set("query", query)
	return c
}

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

// IfNoneMatch sets an optional parameter which makes the operation fail if the
// object's ETag matches the given value. This is useful for getting updates
// only after the object has changed since the last request.
func (c *ProjectsLocationsRegistrationsSearchDomainsCall) IfNoneMatch(entityTag string) *ProjectsLocationsRegistrationsSearchDomainsCall {
	c.ifNoneMatch_ = entityTag
	return c
}

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

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

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

// Do executes the "domains.projects.locations.registrations.searchDomains" call.
// Any non-2xx status code is an error. Response headers are in either
// *SearchDomainsResponse.ServerResponse.Header or (if a response was returned
// at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
// check whether the returned error was because http.StatusNotModified was
// returned.
func (c *ProjectsLocationsRegistrationsSearchDomainsCall) Do(opts ...googleapi.CallOption) (*SearchDomainsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &SearchDomainsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.searchDomains", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsSetIamPolicyCall struct {
	s                   *Service
	resource            string
	setiampolicyrequest *SetIamPolicyRequest
	urlParams_          gensupport.URLParams
	ctx_                context.Context
	header_             http.Header
}

// SetIamPolicy: Sets the access control policy on the specified resource.
// Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
// and `PERMISSION_DENIED` errors.
//
//   - resource: REQUIRED: The resource for which the policy is being specified.
//     See Resource names (https://cloud.google.com/apis/design/resource_names)
//     for the appropriate value for this field.
func (r *ProjectsLocationsRegistrationsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsLocationsRegistrationsSetIamPolicyCall {
	c := &ProjectsLocationsRegistrationsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.resource = resource
	c.setiampolicyrequest = setiampolicyrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.setiampolicyrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:setIamPolicy")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"resource": c.resource,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.setIamPolicy", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.setIamPolicy" call.
// Any non-2xx status code is an error. Response headers are in either
// *Policy.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Policy{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.setIamPolicy", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsTestIamPermissionsCall struct {
	s                         *Service
	resource                  string
	testiampermissionsrequest *TestIamPermissionsRequest
	urlParams_                gensupport.URLParams
	ctx_                      context.Context
	header_                   http.Header
}

// TestIamPermissions: Returns permissions that a caller has on the specified
// resource. If the resource does not exist, this will return an empty set of
// permissions, not a `NOT_FOUND` error. Note: This operation is designed to be
// used for building permission-aware UIs and command-line tools, not for
// authorization checking. This operation may "fail open" without warning.
//
//   - resource: REQUIRED: The resource for which the policy detail is being
//     requested. See Resource names
//     (https://cloud.google.com/apis/design/resource_names) for the appropriate
//     value for this field.
func (r *ProjectsLocationsRegistrationsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsLocationsRegistrationsTestIamPermissionsCall {
	c := &ProjectsLocationsRegistrationsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.resource = resource
	c.testiampermissionsrequest = testiampermissionsrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.testiampermissionsrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+resource}:testIamPermissions")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"resource": c.resource,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.testIamPermissions", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.testIamPermissions" call.
// Any non-2xx status code is an error. Response headers are in either
// *TestIamPermissionsResponse.ServerResponse.Header or (if a response was
// returned at all) in error.(*googleapi.Error).Header. Use
// googleapi.IsNotModified to check whether the returned error was because
// http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &TestIamPermissionsResponse{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.testIamPermissions", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}

type ProjectsLocationsRegistrationsTransferCall struct {
	s                     *Service
	parent                string
	transferdomainrequest *TransferDomainRequest
	urlParams_            gensupport.URLParams
	ctx_                  context.Context
	header_               http.Header
}

// Transfer: Deprecated: For more information, see Cloud Domains feature
// deprecation
// (https://cloud.google.com/domains/docs/deprecations/feature-deprecations)
// Transfers a domain name from another registrar to Cloud Domains. For domains
// already managed by Google Domains (https://domains.google/), use
// `ImportDomain` instead. Before calling this method, go to the domain's
// current registrar to unlock the domain for transfer and retrieve the
// domain's transfer authorization code. Then call `RetrieveTransferParameters`
// to confirm that the domain is unlocked and to get values needed to build a
// call to this method. A successful call creates a `Registration` resource in
// state `TRANSFER_PENDING`. It can take several days to complete the transfer
// process. The registrant can often speed up this process by approving the
// transfer through the current registrar, either by clicking a link in an
// email from the registrar or by visiting the registrar's website. A few
// minutes after transfer approval, the resource transitions to state `ACTIVE`,
// indicating that the transfer was successful. If the transfer is rejected or
// the request expires without being approved, the resource can end up in state
// `TRANSFER_FAILED`. If transfer fails, you can safely delete the resource and
// retry the transfer.
//
//   - parent: The parent resource of the `Registration`. Must be in the format
//     `projects/*/locations/*`.
func (r *ProjectsLocationsRegistrationsService) Transfer(parent string, transferdomainrequest *TransferDomainRequest) *ProjectsLocationsRegistrationsTransferCall {
	c := &ProjectsLocationsRegistrationsTransferCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.parent = parent
	c.transferdomainrequest = transferdomainrequest
	return c
}

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

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

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

func (c *ProjectsLocationsRegistrationsTransferCall) doRequest(alt string) (*http.Response, error) {
	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
	body, err := googleapi.WithoutDataWrapper.JSONBuffer(c.transferdomainrequest)
	if err != nil {
		return nil, err
	}
	c.urlParams_.Set("alt", alt)
	c.urlParams_.Set("prettyPrint", "false")
	urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+parent}/registrations:transfer")
	urls += "?" + c.urlParams_.Encode()
	req, err := http.NewRequest("POST", urls, body)
	if err != nil {
		return nil, err
	}
	req.Header = reqHeaders
	googleapi.Expand(req.URL, map[string]string{
		"parent": c.parent,
	})
	c.s.logger.DebugContext(c.ctx_, "api request", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.transfer", "request", internallog.HTTPRequest(req, body.Bytes()))
	return gensupport.SendRequest(c.ctx_, c.s.client, req)
}

// Do executes the "domains.projects.locations.registrations.transfer" call.
// Any non-2xx status code is an error. Response headers are in either
// *Operation.ServerResponse.Header or (if a response was returned at all) in
// error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
// whether the returned error was because http.StatusNotModified was returned.
func (c *ProjectsLocationsRegistrationsTransferCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
	gensupport.SetOptions(c.urlParams_, opts...)
	res, err := c.doRequest("json")
	if res != nil && res.StatusCode == http.StatusNotModified {
		if res.Body != nil {
			res.Body.Close()
		}
		return nil, gensupport.WrapError(&googleapi.Error{
			Code:   res.StatusCode,
			Header: res.Header,
		})
	}
	if err != nil {
		return nil, err
	}
	defer googleapi.CloseBody(res)
	if err := googleapi.CheckResponse(res); err != nil {
		return nil, gensupport.WrapError(err)
	}
	ret := &Operation{
		ServerResponse: googleapi.ServerResponse{
			Header:         res.Header,
			HTTPStatusCode: res.StatusCode,
		},
	}
	target := &ret
	b, err := gensupport.DecodeResponseBytes(target, res)
	if err != nil {
		return nil, err
	}
	c.s.logger.DebugContext(c.ctx_, "api response", "serviceName", apiName, "rpcName", "domains.projects.locations.registrations.transfer", "response", internallog.HTTPResponse(res, b))
	return ret, nil
}
