Documentation

Overview

Package run provides access to the Cloud Run API.

For product documentation, see: https://cloud.google.com/run/

Creating a client

Usage example:

import "google.golang.org/api/run/v1alpha1"
...
ctx := context.Background()
runService, err := run.NewService(ctx)

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

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

Other authentication options

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

runService, err := run.NewService(ctx, option.WithAPIKey("AIza..."))

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

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

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

Index

Constants

View Source
const (
	// View and manage your data across Google Cloud Platform services
	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type APIService

    type APIService struct {
    	BasePath  string // API endpoint base URL
    	UserAgent string // optional additional User-Agent fragment
    
    	Namespaces *NamespacesService
    
    	Projects *ProjectsService
    	// contains filtered or unexported fields
    }

    func New

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

      New creates a new APIService. It uses the provided http.Client for requests.

      Deprecated: please use NewService instead. To provide a custom HTTP client, use option.WithHTTPClient. If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.

      func NewService

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

        NewService creates a new APIService.

        type Addressable

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

          Addressable: Information for connecting over HTTP(s).

          func (*Addressable) MarshalJSON

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

          type AuditConfig

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

            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.

            func (*AuditConfig) MarshalJSON

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

            type AuditLogConfig

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

              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.

              func (*AuditLogConfig) MarshalJSON

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

              type AuthorizedDomain

              type AuthorizedDomain struct {
              	// Id: Relative name of the domain authorized for use. Example:
              	// `example.com`.
              	Id string `json:"id,omitempty"`
              
              	// Name: Read only. Full path to the `AuthorizedDomain` resource in the
              	// API.
              	// Example: `apps/myapp/authorizedDomains/example.com`.
              	Name string `json:"name,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "Id") to
              	// unconditionally include in API requests. By default, fields with
              	// empty values are omitted from API requests. However, any non-pointer,
              	// non-interface field appearing in ForceSendFields will be sent to the
              	// server regardless of whether the field is empty or not. This may be
              	// used to include empty fields in Patch requests.
              	ForceSendFields []string `json:"-"`
              
              	// NullFields is a list of field names (e.g. "Id") to include in API
              	// requests with the JSON null value. By default, fields with empty
              	// values are omitted from API requests. However, any field with an
              	// empty value appearing in NullFields will be sent to the server as
              	// null. It is an error if a field in this list has a non-empty value.
              	// This may be used to include null fields in Patch requests.
              	NullFields []string `json:"-"`
              }

                AuthorizedDomain: A domain that a user has been authorized to administer. To authorize use of a domain, verify ownership via [Webmaster Central](https://www.google.com/webmasters/verification/home).

                func (*AuthorizedDomain) MarshalJSON

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

                type Binding

                type Binding struct {
                	// Condition: The condition that is associated with this binding.
                	// NOTE: An unsatisfied condition will not allow user access via
                	// current
                	// binding. Different bindings, including their conditions, are
                	// examined
                	// independently.
                	Condition *Expr `json:"condition,omitempty"`
                
                	// Members: Specifies the identities requesting access for a Cloud
                	// Platform 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.
                	//
                	// * `user:{emailid}`: An email address that represents a specific
                	// Google
                	//    account. For example, `alice@example.com` .
                	//
                	//
                	// * `serviceAccount:{emailid}`: An email address that represents a
                	// service
                	//    account. For example,
                	// `my-other-app@appspot.gserviceaccount.com`.
                	//
                	// * `group:{emailid}`: An email address that represents a Google
                	// group.
                	//    For example, `admins@example.com`.
                	//
                	// * `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.
                	//
                	//
                	// * `domain:{domain}`: The G Suite domain (primary) that represents all
                	// the
                	//    users of that domain. For example, `google.com` or
                	// `example.com`.
                	//
                	//
                	Members []string `json:"members,omitempty"`
                
                	// Role: Role that is assigned to `members`.
                	// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
                	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 values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "Condition") to include in
                	// API requests with the JSON null value. By default, fields with empty
                	// values are omitted from API requests. However, any field with an
                	// empty value appearing in NullFields will be sent to the server as
                	// null. It is an error if a field in this list has a non-empty value.
                	// This may be used to include null fields in Patch requests.
                	NullFields []string `json:"-"`
                }

                  Binding: Associates `members` with a `role`.

                  func (*Binding) MarshalJSON

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

                  type Capabilities

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

                    Capabilities: Adds and removes POSIX capabilities from running containers.

                    func (*Capabilities) MarshalJSON

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

                    type CloudAuditLog

                    type CloudAuditLog struct {
                    	// ApiVersion: The API version for this call such as
                    	// "events.cloud.google.com/v1alpha1".
                    	ApiVersion string `json:"apiVersion,omitempty"`
                    
                    	// Kind: The kind of resource, in this case "CloudAuditLog".
                    	Kind string `json:"kind,omitempty"`
                    
                    	// Metadata: Metadata associated with this CloudAuditLog.
                    	Metadata *ObjectMeta `json:"metadata,omitempty"`
                    
                    	// Spec: Spec defines the desired state of the CloudAuditLog.
                    	Spec *CloudAuditLogSpec `json:"spec,omitempty"`
                    
                    	// Status: Status represents the current state of the CloudAuditLog.
                    	// This data may be
                    	// out of date. +optional
                    	Status *CloudAuditLogStatus `json:"status,omitempty"`
                    
                    	// ServerResponse contains the HTTP response code and headers from the
                    	// server.
                    	googleapi.ServerResponse `json:"-"`
                    
                    	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
                    	// unconditionally include in API requests. By default, fields with
                    	// empty values are omitted from API requests. However, any non-pointer,
                    	// non-interface field appearing in ForceSendFields will be sent to the
                    	// server regardless of whether the field is empty or not. This may be
                    	// used to include empty fields in Patch requests.
                    	ForceSendFields []string `json:"-"`
                    
                    	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                    	// API requests with the JSON null value. By default, fields with empty
                    	// values are omitted from API requests. However, any field with an
                    	// empty value appearing in NullFields will be sent to the server as
                    	// null. It is an error if a field in this list has a non-empty value.
                    	// This may be used to include null fields in Patch requests.
                    	NullFields []string `json:"-"`
                    }

                    func (*CloudAuditLog) MarshalJSON

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

                    type CloudAuditLogSpec

                    type CloudAuditLogSpec struct {
                    	// CeOverrides: CloudEventOverrides defines overrides to control the
                    	// output format and
                    	// modifications of the event sent to the sink.
                    	// +optional
                    	CeOverrides *CloudEventOverrides `json:"ceOverrides,omitempty"`
                    
                    	// MethodName: Required. The method name at the service API. This must
                    	// match "methodName" in Cloud
                    	// Audit Logs. Regex or Wildcards (*) are not supported.
                    	// Example: "google.cloud.bigquery.job.create".
                    	MethodName string `json:"methodName,omitempty"`
                    
                    	// Project: Project is the ID of the Google Cloud Project that the
                    	// PubSub Topic exists
                    	// in. If omitted, defaults to same as the cluster. +optional
                    	Project string `json:"project,omitempty"`
                    
                    	// PubsubSecret: PubSubSecret is the credential to use to create
                    	// Topic / PullSubscription resources. If omitted, uses Secret.
                    	PubsubSecret *SecretKeySelector `json:"pubsubSecret,omitempty"`
                    
                    	// ResourceName: Optional. The resource specification. This must match
                    	// "methodName"
                    	// in Cloud Audit Logs. Regex or Wildcards (*) are not
                    	// supported.
                    	// Example: "projects/my-project/jobs/foo".
                    	ResourceName string `json:"resourceName,omitempty"`
                    
                    	// Secret: Secret is the credential to use to create the Scheduler
                    	// Job.
                    	// If not specified, defaults to:
                    	// Name: google-cloud-key
                    	// Key: key.json
                    	// +optional
                    	Secret *SecretKeySelector `json:"secret,omitempty"`
                    
                    	// ServiceAccountName: Email address of the IAM service account
                    	// associated with the source. The
                    	// service account represents the identity of the source, and determines
                    	// what
                    	// permissions the source has. If not provided, the source will use
                    	// the
                    	// project's default service account.
                    	// +optional
                    	ServiceAccountName string `json:"serviceAccountName,omitempty"`
                    
                    	// ServiceName: Required. The GCP service name. This must match
                    	// "serviceName" in Cloud Audit Logs.
                    	// Regex or Wildcards (*) are not supported.
                    	// Example: "bigquery.googleapis.com".
                    	ServiceName string `json:"serviceName,omitempty"`
                    
                    	// Sink: Sink is a reference to an object that will resolve to a domain
                    	// name or a
                    	// URI directly to use as the sink.
                    	Sink *Destination `json:"sink,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "CeOverrides") to
                    	// unconditionally include in API requests. By default, fields with
                    	// empty values are omitted from API requests. However, any non-pointer,
                    	// non-interface field appearing in ForceSendFields will be sent to the
                    	// server regardless of whether the field is empty or not. This may be
                    	// used to include empty fields in Patch requests.
                    	ForceSendFields []string `json:"-"`
                    
                    	// NullFields is a list of field names (e.g. "CeOverrides") to include
                    	// in API requests with the JSON null value. By default, fields with
                    	// empty values are omitted from API requests. However, any field with
                    	// an empty value appearing in NullFields will be sent to the server as
                    	// null. It is an error if a field in this list has a non-empty value.
                    	// This may be used to include null fields in Patch requests.
                    	NullFields []string `json:"-"`
                    }

                      CloudAuditLogSpec: The desired state of the CloudAuditLog.

                      func (*CloudAuditLogSpec) MarshalJSON

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

                      type CloudAuditLogStatus

                      type CloudAuditLogStatus struct {
                      	// Conditions: Array of observed CloudAuditLogConditions, indicating the
                      	// current state
                      	// of the CloudAuditLog.
                      	Conditions []*Condition `json:"conditions,omitempty"`
                      
                      	// ObservedGeneration: ObservedGeneration is the 'Generation' of the
                      	// CloudAuditLog that
                      	// was last processed by the controller.
                      	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
                      
                      	// SinkUri: SinkURI is the current active sink URI that has been
                      	// configured for the
                      	// Source.
                      	// +optional
                      	SinkUri string `json:"sinkUri,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "Conditions") to
                      	// unconditionally include in API requests. By default, fields with
                      	// empty values are omitted from API requests. However, any non-pointer,
                      	// non-interface field appearing in ForceSendFields will be sent to the
                      	// server regardless of whether the field is empty or not. This may be
                      	// used to include empty fields in Patch requests.
                      	ForceSendFields []string `json:"-"`
                      
                      	// NullFields is a list of field names (e.g. "Conditions") to include in
                      	// API requests with the JSON null value. By default, fields with empty
                      	// values are omitted from API requests. However, any field with an
                      	// empty value appearing in NullFields will be sent to the server as
                      	// null. It is an error if a field in this list has a non-empty value.
                      	// This may be used to include null fields in Patch requests.
                      	NullFields []string `json:"-"`
                      }

                        CloudAuditLogStatus: CloudAuditLogStatus represents the current state of a CloudAuditLog.

                        func (*CloudAuditLogStatus) MarshalJSON

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

                        type CloudEventOverrides

                        type CloudEventOverrides struct {
                        	// Extensions: Extensions specify what attribute are added or overridden
                        	// on the outbound
                        	// event. Each `Extensions` key-value pair are set on the event as
                        	// an
                        	// attribute extension independently.
                        	// +optional
                        	Extensions map[string]string `json:"extensions,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "Extensions") to
                        	// unconditionally include in API requests. By default, fields with
                        	// empty values are omitted from API requests. However, any non-pointer,
                        	// non-interface field appearing in ForceSendFields will be sent to the
                        	// server regardless of whether the field is empty or not. This may be
                        	// used to include empty fields in Patch requests.
                        	ForceSendFields []string `json:"-"`
                        
                        	// NullFields is a list of field names (e.g. "Extensions") to include in
                        	// API requests with the JSON null value. By default, fields with empty
                        	// values are omitted from API requests. However, any field with an
                        	// empty value appearing in NullFields will be sent to the server as
                        	// null. It is an error if a field in this list has a non-empty value.
                        	// This may be used to include null fields in Patch requests.
                        	NullFields []string `json:"-"`
                        }

                          CloudEventOverrides: CloudEventOverrides defines arguments for a Source that control the output format of the CloudEvents produced by the Source.

                          func (*CloudEventOverrides) MarshalJSON

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

                          type Condition

                          type Condition struct {
                          	// LastTransitionTime: Optional. Last time the condition transitioned
                          	// from one status to another.
                          	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
                          
                          	// Message: Optional. Human readable message indicating details about
                          	// the current status.
                          	Message string `json:"message,omitempty"`
                          
                          	// Reason: Optional. One-word CamelCase reason for the condition's last
                          	// transition.
                          	Reason string `json:"reason,omitempty"`
                          
                          	// Severity: Optional. How to interpret failures of this condition, one
                          	// of Error, Warning, Info
                          	Severity string `json:"severity,omitempty"`
                          
                          	// Status: Status of the condition, one of True, False, Unknown.
                          	Status string `json:"status,omitempty"`
                          
                          	// Type: type is used to communicate the status of the reconciliation
                          	// process.
                          	// See
                          	// also:
                          	// https://github.com/knative/serving/blob/master/docs/spec/errors.
                          	// md#error-conditions-and-reporting
                          	// Types common to all resources include:
                          	// * "Ready": True when the Resource is ready.
                          	Type string `json:"type,omitempty"`
                          
                          	// ForceSendFields is a list of field names (e.g. "LastTransitionTime")
                          	// to unconditionally include in API requests. By default, fields with
                          	// empty values are omitted from API requests. However, any non-pointer,
                          	// non-interface field appearing in ForceSendFields will be sent to the
                          	// server regardless of whether the field is empty or not. This may be
                          	// used to include empty fields in Patch requests.
                          	ForceSendFields []string `json:"-"`
                          
                          	// NullFields is a list of field names (e.g. "LastTransitionTime") to
                          	// include in API requests with the JSON null value. By default, fields
                          	// with empty values are omitted from API requests. However, any field
                          	// with an empty value appearing in NullFields will be sent to the
                          	// server as null. It is an error if a field in this list has a
                          	// non-empty value. This may be used to include null fields in Patch
                          	// requests.
                          	NullFields []string `json:"-"`
                          }

                            Condition: Condition defines a generic condition for a Resource

                            func (*Condition) MarshalJSON

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

                            type ConfigMapEnvSource

                            type ConfigMapEnvSource struct {
                            	// LocalObjectReference: This field should not be used directly as it is
                            	// meant to be inlined
                            	// directly into the message. Use the "name" field instead.
                            	LocalObjectReference *LocalObjectReference `json:"localObjectReference,omitempty"`
                            
                            	// Name: Cloud Run fully managed: not supported
                            	//
                            	// Cloud Run for Anthos: supported
                            	//
                            	// The ConfigMap to select from.
                            	Name string `json:"name,omitempty"`
                            
                            	// Optional: Cloud Run fully managed: not supported
                            	//
                            	// Cloud Run for Anthos: supported
                            	//
                            	// Specify whether the ConfigMap must be defined
                            	// +optional
                            	Optional bool `json:"optional,omitempty"`
                            
                            	// ForceSendFields is a list of field names (e.g.
                            	// "LocalObjectReference") to unconditionally include in API requests.
                            	// By default, fields with empty values are omitted from API requests.
                            	// However, any non-pointer, non-interface field appearing in
                            	// ForceSendFields will be sent to the server regardless of whether the
                            	// field is empty or not. This may be used to include empty fields in
                            	// Patch requests.
                            	ForceSendFields []string `json:"-"`
                            
                            	// NullFields is a list of field names (e.g. "LocalObjectReference") to
                            	// include in API requests with the JSON null value. By default, fields
                            	// with empty values are omitted from API requests. However, any field
                            	// with an empty value appearing in NullFields will be sent to the
                            	// server as null. It is an error if a field in this list has a
                            	// non-empty value. This may be used to include null fields in Patch
                            	// requests.
                            	NullFields []string `json:"-"`
                            }

                              ConfigMapEnvSource: ConfigMapEnvSource selects a ConfigMap to populate the environment variables with.

                              The contents of the target ConfigMap's Data field will represent the key-value pairs as environment variables.

                              func (*ConfigMapEnvSource) MarshalJSON

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

                              type ConfigMapKeySelector

                              type ConfigMapKeySelector struct {
                              	// Key: Cloud Run fully managed: not supported
                              	//
                              	// Cloud Run on GKE: supported
                              	//
                              	// The key to select.
                              	Key string `json:"key,omitempty"`
                              
                              	// LocalObjectReference: This field should not be used directly as it is
                              	// meant to be inlined
                              	// directly into the message. Use the "name" field instead.
                              	LocalObjectReference *LocalObjectReference `json:"localObjectReference,omitempty"`
                              
                              	// Name: Cloud Run fully managed: not supported
                              	//
                              	// Cloud Run on GKE: supported
                              	//
                              	// The ConfigMap to select from.
                              	Name string `json:"name,omitempty"`
                              
                              	// Optional: Cloud Run fully managed: not supported
                              	//
                              	// Cloud Run on GKE: supported
                              	//
                              	// Specify whether the ConfigMap or its key must be defined
                              	// +optional
                              	Optional bool `json:"optional,omitempty"`
                              
                              	// ForceSendFields is a list of field names (e.g. "Key") to
                              	// unconditionally include in API requests. By default, fields with
                              	// empty values are omitted from API requests. However, any non-pointer,
                              	// non-interface field appearing in ForceSendFields will be sent to the
                              	// server regardless of whether the field is empty or not. This may be
                              	// used to include empty fields in Patch requests.
                              	ForceSendFields []string `json:"-"`
                              
                              	// NullFields is a list of field names (e.g. "Key") to include in API
                              	// requests with the JSON null value. By default, fields with empty
                              	// values are omitted from API requests. However, any field with an
                              	// empty value appearing in NullFields will be sent to the server as
                              	// null. It is an error if a field in this list has a non-empty value.
                              	// This may be used to include null fields in Patch requests.
                              	NullFields []string `json:"-"`
                              }

                                ConfigMapKeySelector: Cloud Run fully managed: not supported

                                Cloud Run on GKE: supported

                                Selects a key from a ConfigMap.

                                func (*ConfigMapKeySelector) MarshalJSON

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

                                type ConfigMapVolumeSource

                                type ConfigMapVolumeSource struct {
                                	// DefaultMode: Mode bits to use on created files by default. Must be a
                                	// value between 0 and
                                	// 0777. Defaults to 0644. Directories within the path are not affected
                                	// by
                                	// this setting. This might be in conflict with other options that
                                	// affect the
                                	// file mode, like fsGroup, and the result can be other mode bits set.
                                	DefaultMode int64 `json:"defaultMode,omitempty"`
                                
                                	// Items: If unspecified, each key-value pair in the Data field of the
                                	// referenced
                                	// Secret will be projected into the volume as a file whose name is
                                	// the
                                	// key and content is the value. If specified, the listed keys will
                                	// be
                                	// projected into the specified paths, and unlisted keys will not
                                	// be
                                	// present. If a key is specified which is not present in the
                                	// Secret,
                                	// the volume setup will error unless it is marked optional.
                                	Items []*KeyToPath `json:"items,omitempty"`
                                
                                	// Name: Name of the config.
                                	Name string `json:"name,omitempty"`
                                
                                	// Optional: Specify whether the Secret or its keys must be defined.
                                	Optional bool `json:"optional,omitempty"`
                                
                                	// ForceSendFields is a list of field names (e.g. "DefaultMode") to
                                	// unconditionally include in API requests. By default, fields with
                                	// empty values are omitted from API requests. However, any non-pointer,
                                	// non-interface field appearing in ForceSendFields will be sent to the
                                	// server regardless of whether the field is empty or not. This may be
                                	// used to include empty fields in Patch requests.
                                	ForceSendFields []string `json:"-"`
                                
                                	// NullFields is a list of field names (e.g. "DefaultMode") to include
                                	// in API requests with the JSON null value. By default, fields with
                                	// empty values are omitted from API requests. However, any field with
                                	// an empty value appearing in NullFields will be sent to the server as
                                	// null. It is an error if a field in this list has a non-empty value.
                                	// This may be used to include null fields in Patch requests.
                                	NullFields []string `json:"-"`
                                }

                                  ConfigMapVolumeSource: Adapts a ConfigMap into a volume. The contents of the target ConfigMap's Data field will be presented in a volume as files using the keys in the Data field as the file names, unless the items element is populated with specific mappings of keys to paths.

                                  func (*ConfigMapVolumeSource) MarshalJSON

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

                                  type Configuration

                                  type Configuration struct {
                                  	// ApiVersion: The API version for this call such as
                                  	// "serving.knative.dev/v1alpha1".
                                  	ApiVersion string `json:"apiVersion,omitempty"`
                                  
                                  	// Kind: The kind of resource, in this case always "Configuration".
                                  	Kind string `json:"kind,omitempty"`
                                  
                                  	// Metadata: Metadata associated with this Configuration, including
                                  	// name, namespace,
                                  	// labels, and annotations.
                                  	Metadata *ObjectMeta `json:"metadata,omitempty"`
                                  
                                  	// Spec: Spec holds the desired state of the Configuration (from the
                                  	// client).
                                  	Spec *ConfigurationSpec `json:"spec,omitempty"`
                                  
                                  	// Status: Status communicates the observed state of the Configuration
                                  	// (from the
                                  	// controller).
                                  	Status *ConfigurationStatus `json:"status,omitempty"`
                                  
                                  	// ServerResponse contains the HTTP response code and headers from the
                                  	// server.
                                  	googleapi.ServerResponse `json:"-"`
                                  
                                  	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
                                  	// unconditionally include in API requests. By default, fields with
                                  	// empty values are omitted from API requests. However, any non-pointer,
                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                  	// server regardless of whether the field is empty or not. This may be
                                  	// used to include empty fields in Patch requests.
                                  	ForceSendFields []string `json:"-"`
                                  
                                  	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                  	// API requests with the JSON null value. By default, fields with empty
                                  	// values are omitted from API requests. However, any field with an
                                  	// empty value appearing in NullFields will be sent to the server as
                                  	// null. It is an error if a field in this list has a non-empty value.
                                  	// This may be used to include null fields in Patch requests.
                                  	NullFields []string `json:"-"`
                                  }

                                    Configuration: Configuration represents the "floating HEAD" of a linear history of Revisions, and optionally how the containers those revisions reference are built. Users create new Revisions by updating the Configuration's spec. The "latest created" revision's name is available under status, as is the "latest ready" revision's name. See also: https://github.com/knative/serving/blob/master/docs/spec/overvie w.md#configuration

                                    func (*Configuration) MarshalJSON

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

                                    type ConfigurationCondition

                                    type ConfigurationCondition struct {
                                    	// LastTransitionTime: Last time the condition transitioned from one
                                    	// status to another.
                                    	// +optional
                                    	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
                                    
                                    	// Message: Human-readable message indicating details about last
                                    	// transition.
                                    	// +optional
                                    	Message string `json:"message,omitempty"`
                                    
                                    	// Reason: One-word CamelCase reason for the condition's last
                                    	// transition.
                                    	// +optional
                                    	Reason string `json:"reason,omitempty"`
                                    
                                    	// Severity: How to interpret failures of this condition, one of Error,
                                    	// Warning, Info
                                    	// +optional
                                    	Severity string `json:"severity,omitempty"`
                                    
                                    	// Status: Status of the condition, one of True, False, Unknown.
                                    	Status string `json:"status,omitempty"`
                                    
                                    	// Type: ConfigurationConditionType is used to communicate the status of
                                    	// the
                                    	// reconciliation process. See
                                    	// also:
                                    	// https://github.com/knative/serving/blob/master/docs/spec/errors.
                                    	// md#error-conditions-and-reporting
                                    	// Types include:"Ready"
                                    	Type string `json:"type,omitempty"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "LastTransitionTime")
                                    	// to unconditionally include in API requests. By default, fields with
                                    	// empty values are omitted from API requests. However, any non-pointer,
                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                    	// server regardless of whether the field is empty or not. This may be
                                    	// used to include empty fields in Patch requests.
                                    	ForceSendFields []string `json:"-"`
                                    
                                    	// NullFields is a list of field names (e.g. "LastTransitionTime") to
                                    	// include in API requests with the JSON null value. By default, fields
                                    	// with empty values are omitted from API requests. However, any field
                                    	// with an empty value appearing in NullFields will be sent to the
                                    	// server as null. It is an error if a field in this list has a
                                    	// non-empty value. This may be used to include null fields in Patch
                                    	// requests.
                                    	NullFields []string `json:"-"`
                                    }

                                      ConfigurationCondition: ConfigurationCondition defines a readiness condition for a Configuration.

                                      func (*ConfigurationCondition) MarshalJSON

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

                                      type ConfigurationSpec

                                      type ConfigurationSpec struct {
                                      	// Generation: Deprecated and not currently populated by Cloud Run.
                                      	// See
                                      	// metadata.generation instead, which is the sequence number containing
                                      	// the
                                      	// latest generation of the desired state.
                                      	//
                                      	// Read-only.
                                      	Generation int64 `json:"generation,omitempty"`
                                      
                                      	// RevisionTemplate: RevisionTemplate holds the latest specification for
                                      	// the Revision to
                                      	// be stamped out. The template references the container image, and may
                                      	// also
                                      	// include labels and annotations that should be attached to the
                                      	// Revision.
                                      	// To correlate a Revision, and/or to force a Revision to be created
                                      	// when the
                                      	// spec doesn't otherwise change, a nonce label may be provided in
                                      	// the
                                      	// template metadata. For more details,
                                      	// see:
                                      	// https://github.com/knative/serving/blob/master/docs/client-conven
                                      	// tions.md#associate-modifications-with-revisions
                                      	//
                                      	// Cloud Run does not currently support referencing a build that
                                      	// is
                                      	// responsible for materializing the container image from source.
                                      	RevisionTemplate *RevisionTemplate `json:"revisionTemplate,omitempty"`
                                      
                                      	// Template: Template holds the latest specification for the Revision to
                                      	// be stamped out.
                                      	Template *RevisionTemplate `json:"template,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Generation") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Generation") to include in
                                      	// API requests with the JSON null value. By default, fields with empty
                                      	// values are omitted from API requests. However, any field with an
                                      	// empty value appearing in NullFields will be sent to the server as
                                      	// null. It is an error if a field in this list has a non-empty value.
                                      	// This may be used to include null fields in Patch requests.
                                      	NullFields []string `json:"-"`
                                      }

                                        ConfigurationSpec: ConfigurationSpec holds the desired state of the Configuration (from the client).

                                        func (*ConfigurationSpec) MarshalJSON

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

                                        type ConfigurationStatus

                                        type ConfigurationStatus struct {
                                        	// Conditions: Conditions communicates information about
                                        	// ongoing/complete
                                        	// reconciliation processes that bring the "spec" inline with the
                                        	// observed
                                        	// state of the world.
                                        	Conditions []*ConfigurationCondition `json:"conditions,omitempty"`
                                        
                                        	// LatestCreatedRevisionName: LatestCreatedRevisionName is the last
                                        	// revision that was created from this
                                        	// Configuration. It might not be ready yet, for that
                                        	// use
                                        	// LatestReadyRevisionName.
                                        	LatestCreatedRevisionName string `json:"latestCreatedRevisionName,omitempty"`
                                        
                                        	// LatestReadyRevisionName: LatestReadyRevisionName holds the name of
                                        	// the latest Revision stamped out
                                        	// from this Configuration that has had its "Ready" condition become
                                        	// "True".
                                        	LatestReadyRevisionName string `json:"latestReadyRevisionName,omitempty"`
                                        
                                        	// ObservedGeneration: ObservedGeneration is the 'Generation' of the
                                        	// Configuration that
                                        	// was last processed by the controller. The observed generation is
                                        	// updated
                                        	// even if the controller failed to process the spec and create the
                                        	// Revision.
                                        	//
                                        	// Clients polling for completed reconciliation should poll
                                        	// until
                                        	// observedGeneration = metadata.generation, and the Ready condition's
                                        	// status
                                        	// is True or False.
                                        	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
                                        
                                        	// ForceSendFields is a list of field names (e.g. "Conditions") to
                                        	// unconditionally include in API requests. By default, fields with
                                        	// empty values are omitted from API requests. However, any non-pointer,
                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                        	// server regardless of whether the field is empty or not. This may be
                                        	// used to include empty fields in Patch requests.
                                        	ForceSendFields []string `json:"-"`
                                        
                                        	// NullFields is a list of field names (e.g. "Conditions") to include in
                                        	// API requests with the JSON null value. By default, fields with empty
                                        	// values are omitted from API requests. However, any field with an
                                        	// empty value appearing in NullFields will be sent to the server as
                                        	// null. It is an error if a field in this list has a non-empty value.
                                        	// This may be used to include null fields in Patch requests.
                                        	NullFields []string `json:"-"`
                                        }

                                          ConfigurationStatus: ConfigurationStatus communicates the observed state of the Configuration (from the controller).

                                          func (*ConfigurationStatus) MarshalJSON

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

                                          type Container

                                          type Container struct {
                                          	// Args: Arguments to the entrypoint.
                                          	// The docker image's CMD is used if this is not provided.
                                          	// Variable references $(VAR_NAME) are expanded using the
                                          	// container's
                                          	// environment. If a variable cannot be resolved, the reference in the
                                          	// input
                                          	// string will be unchanged. The $(VAR_NAME) syntax can be escaped with
                                          	// a
                                          	// double $$, ie: $$(VAR_NAME). Escaped references will never be
                                          	// expanded,
                                          	// regardless of whether the variable exists or not.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/tasks/inject-data-application/define-
                                          	// command-argument-container/#running-a-command-in-a-shell
                                          	// +optional
                                          	Args []string `json:"args,omitempty"`
                                          
                                          	// Command: Entrypoint array. Not executed within a shell.
                                          	// The docker image's ENTRYPOINT is used if this is not
                                          	// provided.
                                          	// Variable references $(VAR_NAME) are expanded using the
                                          	// container's
                                          	// environment. If a variable cannot be resolved, the reference in the
                                          	// input
                                          	// string will be unchanged. The $(VAR_NAME) syntax can be escaped with
                                          	// a
                                          	// double $$, ie: $$(VAR_NAME). Escaped references will never be
                                          	// expanded,
                                          	// regardless of whether the variable exists or not.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/tasks/inject-data-application/define-
                                          	// command-argument-container/#running-a-command-in-a-shell
                                          	// +optional
                                          	Command []string `json:"command,omitempty"`
                                          
                                          	// Env: List of environment variables to set in the container.
                                          	// Cannot be updated.
                                          	// +optional
                                          	Env []*EnvVar `json:"env,omitempty"`
                                          
                                          	// EnvFrom: List of sources to populate environment variables in the
                                          	// container.
                                          	// The keys defined within a source must be a C_IDENTIFIER. All invalid
                                          	// keys
                                          	// will be reported as an event when the container is starting. When a
                                          	// key
                                          	// exists in multiple sources, the value associated with the last source
                                          	// will
                                          	// take precedence. Values defined by an Env with a duplicate key will
                                          	// take
                                          	// precedence. Cannot be updated. +optional
                                          	EnvFrom []*EnvFromSource `json:"envFrom,omitempty"`
                                          
                                          	// Image: Docker image name.
                                          	// More info: https://kubernetes.io/docs/concepts/containers/images
                                          	Image string `json:"image,omitempty"`
                                          
                                          	// ImagePullPolicy: Image pull policy.
                                          	// One of Always, Never, IfNotPresent.
                                          	// Defaults to Always if :latest tag is specified, or IfNotPresent
                                          	// otherwise.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/concepts/containers/images#updating-i
                                          	// mages
                                          	// +optional
                                          	ImagePullPolicy string `json:"imagePullPolicy,omitempty"`
                                          
                                          	// Lifecycle: Actions that the management system should take in response
                                          	// to container
                                          	// lifecycle events. Cannot be updated. +optional
                                          	Lifecycle *Lifecycle `json:"lifecycle,omitempty"`
                                          
                                          	// LivenessProbe: Periodic probe of container liveness.
                                          	// Container will be restarted if the probe fails.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle
                                          	// #container-probes
                                          	// +optional
                                          	LivenessProbe *Probe `json:"livenessProbe,omitempty"`
                                          
                                          	// Name: Name of the container specified as a DNS_LABEL.
                                          	// Each container must have a unique name (DNS_LABEL).
                                          	// Cannot be updated.
                                          	Name string `json:"name,omitempty"`
                                          
                                          	// Ports: List of ports to expose from the container. Exposing a port
                                          	// here gives
                                          	// the system additional information about the network connections
                                          	// a
                                          	// container uses, but is primarily informational. Not specifying a port
                                          	// here
                                          	// DOES NOT prevent that port from being exposed. Any port which
                                          	// is
                                          	// listening on the default "0.0.0.0" address inside a container will
                                          	// be
                                          	// accessible from the network.
                                          	// Cannot be updated.
                                          	// +optional
                                          	Ports []*ContainerPort `json:"ports,omitempty"`
                                          
                                          	// ReadinessProbe: Periodic probe of container service
                                          	// readiness.
                                          	// Container will be removed from service endpoints if the probe
                                          	// fails.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle
                                          	// #container-probes
                                          	// +optional
                                          	ReadinessProbe *Probe `json:"readinessProbe,omitempty"`
                                          
                                          	// Resources: Compute Resources required by this container.
                                          	// Cannot be updated.
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/concepts/storage/persistent-volumes#r
                                          	// esources
                                          	// +optional
                                          	Resources *ResourceRequirements `json:"resources,omitempty"`
                                          
                                          	// SecurityContext: Security options the pod should run with.
                                          	// More info:
                                          	// https://kubernetes.io/docs/concepts/policy/security-context/
                                          	// More
                                          	// info:
                                          	// https://kubernetes.io/docs/tasks/configure-pod-container/securit
                                          	// y-context/
                                          	// +optional
                                          	SecurityContext *SecurityContext `json:"securityContext,omitempty"`
                                          
                                          	// Stdin: Whether this container should allocate a buffer for stdin in
                                          	// the container
                                          	// runtime. If this is not set, reads from stdin in the container will
                                          	// always
                                          	// result in EOF. Default is false. +optional
                                          	Stdin bool `json:"stdin,omitempty"`
                                          
                                          	// StdinOnce: Whether the container runtime should close the stdin
                                          	// channel after it has
                                          	// been opened by a single attach. When stdin is true the stdin stream
                                          	// will
                                          	// remain open across multiple attach sessions. If stdinOnce is set to
                                          	// true,
                                          	// stdin is opened on container start, is empty until the first
                                          	// client
                                          	// attaches to stdin, and then remains open and accepts data until the
                                          	// client
                                          	// disconnects, at which time stdin is closed and remains closed until
                                          	// the
                                          	// container is restarted. If this flag is false, a container processes
                                          	// that
                                          	// reads from stdin will never receive an EOF. Default is false
                                          	// +optional
                                          	StdinOnce bool `json:"stdinOnce,omitempty"`
                                          
                                          	// TerminationMessagePath: Optional: Path at which the file to which the
                                          	// container's termination
                                          	// message will be written is mounted into the container's filesystem.
                                          	// Message
                                          	// written is intended to be brief final status, such as an assertion
                                          	// failure
                                          	// message. Will be truncated by the node if greater than 4096 bytes.
                                          	// The
                                          	// total message length across all containers will be limited to
                                          	// 12kb.
                                          	// Defaults to /dev/termination-log.
                                          	// Cannot be updated.
                                          	// +optional
                                          	TerminationMessagePath string `json:"terminationMessagePath,omitempty"`
                                          
                                          	// TerminationMessagePolicy: Indicate how the termination message should
                                          	// be populated. File will use the
                                          	// contents of terminationMessagePath to populate the container status
                                          	// message
                                          	// on both success and failure. FallbackToLogsOnError will use the last
                                          	// chunk
                                          	// of container log output if the termination message file is empty and
                                          	// the
                                          	// container exited with an error. The log output is limited to 2048
                                          	// bytes or
                                          	// 80 lines, whichever is smaller. Defaults to File. Cannot be
                                          	// updated.
                                          	// +optional
                                          	TerminationMessagePolicy string `json:"terminationMessagePolicy,omitempty"`
                                          
                                          	// Tty: Whether this container should allocate a TTY for itself, also
                                          	// requires
                                          	// 'stdin' to be true. Default is false. +optional
                                          	Tty bool `json:"tty,omitempty"`
                                          
                                          	// VolumeDevices: volumeDevices is the list of block devices to be used
                                          	// by the container.
                                          	// This is an alpha feature and may change in the future.
                                          	// +optional
                                          	VolumeDevices []*VolumeDevice `json:"volumeDevices,omitempty"`
                                          
                                          	// VolumeMounts: Pod volumes to mount into the container's
                                          	// filesystem.
                                          	// Cannot be updated.
                                          	// +optional
                                          	VolumeMounts []*VolumeMount `json:"volumeMounts,omitempty"`
                                          
                                          	// WorkingDir: Container's working directory.
                                          	// If not specified, the container runtime's default will be used,
                                          	// which
                                          	// might be configured in the container image.
                                          	// Cannot be updated.
                                          	// +optional
                                          	WorkingDir string `json:"workingDir,omitempty"`
                                          
                                          	// ForceSendFields is a list of field names (e.g. "Args") to
                                          	// unconditionally include in API requests. By default, fields with
                                          	// empty values are omitted from API requests. However, any non-pointer,
                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                          	// server regardless of whether the field is empty or not. This may be
                                          	// used to include empty fields in Patch requests.
                                          	ForceSendFields []string `json:"-"`
                                          
                                          	// NullFields is a list of field names (e.g. "Args") to include in API
                                          	// requests with the JSON null value. By default, fields with empty
                                          	// values are omitted from API requests. However, any field with an
                                          	// empty value appearing in NullFields will be sent to the server as
                                          	// null. It is an error if a field in this list has a non-empty value.
                                          	// This may be used to include null fields in Patch requests.
                                          	NullFields []string `json:"-"`
                                          }

                                            Container: A single application container. This specifies both the container to run, the command to run in the container and the arguments to supply to it. Note that additional arguments may be supplied by the system to the container at runtime.

                                            func (*Container) MarshalJSON

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

                                            type ContainerPort

                                            type ContainerPort struct {
                                            	// ContainerPort: Number of port to expose on the pod's IP address.
                                            	// This must be a valid port number, 0 < x < 65536.
                                            	ContainerPort int64 `json:"containerPort,omitempty"`
                                            
                                            	// HostIP: What host IP to bind the external port to.
                                            	// +optional
                                            	HostIP string `json:"hostIP,omitempty"`
                                            
                                            	// HostPort: Number of port to expose on the host.
                                            	// If specified, this must be a valid port number, 0 < x < 65536.
                                            	// If HostNetwork is specified, this must match ContainerPort.
                                            	// Most containers do not need this.
                                            	// +optional
                                            	HostPort int64 `json:"hostPort,omitempty"`
                                            
                                            	// Name: If specified, this must be an IANA_SVC_NAME and unique within
                                            	// the pod. Each
                                            	// named port in a pod must have a unique name. Name for the port that
                                            	// can be
                                            	// referred to by services.
                                            	// +optional
                                            	Name string `json:"name,omitempty"`
                                            
                                            	// Protocol: Protocol for port. Must be UDP or TCP.
                                            	// Defaults to "TCP".
                                            	// +optional
                                            	Protocol string `json:"protocol,omitempty"`
                                            
                                            	// ForceSendFields is a list of field names (e.g. "ContainerPort") to
                                            	// unconditionally include in API requests. By default, fields with
                                            	// empty values are omitted from API requests. However, any non-pointer,
                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                            	// server regardless of whether the field is empty or not. This may be
                                            	// used to include empty fields in Patch requests.
                                            	ForceSendFields []string `json:"-"`
                                            
                                            	// NullFields is a list of field names (e.g. "ContainerPort") to include
                                            	// in API requests with the JSON null value. By default, fields with
                                            	// empty values are omitted from API requests. However, any field with
                                            	// an empty value appearing in NullFields will be sent to the server as
                                            	// null. It is an error if a field in this list has a non-empty value.
                                            	// This may be used to include null fields in Patch requests.
                                            	NullFields []string `json:"-"`
                                            }

                                              ContainerPort: ContainerPort represents a network port in a single container.

                                              func (*ContainerPort) MarshalJSON

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

                                              type Destination

                                              type Destination struct {
                                              	// Ref: ObjectReference points to an Addressable.
                                              	// + optional
                                              	Ref *ObjectReference `json:"ref,omitempty"`
                                              
                                              	// Uri: URI is for direct URI Designations or used with the resulting
                                              	// URL from
                                              	// Addressable ObjectReference. If used with an ObjectReference, will
                                              	// be
                                              	// appended to the path of the resulting URL from the Addressable.
                                              	// + optional
                                              	Uri string `json:"uri,omitempty"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "Ref") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "Ref") to include in API
                                              	// requests with the JSON null value. By default, fields with empty
                                              	// values are omitted from API requests. However, any field with an
                                              	// empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                              func (*Destination) MarshalJSON

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

                                              type DomainMapping

                                              type DomainMapping struct {
                                              	// ApiVersion: The API version for this call such as
                                              	// "domains.cloudrun.com/v1alpha1".
                                              	ApiVersion string `json:"apiVersion,omitempty"`
                                              
                                              	// Kind: The kind of resource, in this case "DomainMapping".
                                              	Kind string `json:"kind,omitempty"`
                                              
                                              	// Metadata: Metadata associated with this BuildTemplate.
                                              	Metadata *ObjectMeta `json:"metadata,omitempty"`
                                              
                                              	// Spec: The spec for this DomainMapping.
                                              	Spec *DomainMappingSpec `json:"spec,omitempty"`
                                              
                                              	// Status: The current status of the DomainMapping.
                                              	Status *DomainMappingStatus `json:"status,omitempty"`
                                              
                                              	// ServerResponse contains the HTTP response code and headers from the
                                              	// server.
                                              	googleapi.ServerResponse `json:"-"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                              	// API requests with the JSON null value. By default, fields with empty
                                              	// values are omitted from API requests. However, any field with an
                                              	// empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                DomainMapping: Resource to hold the state and status of a user's domain mapping.

                                                func (*DomainMapping) MarshalJSON

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

                                                type DomainMappingCondition

                                                type DomainMappingCondition struct {
                                                	// LastTransitionTime: Last time the condition transitioned from one
                                                	// status to another.
                                                	// +optional
                                                	LastTransitionTime string `json:"lastTransitionTime,omitempty"`
                                                
                                                	// Message: Human readable message indicating details about the current
                                                	// status.
                                                	// +optional
                                                	Message string `json:"message,omitempty"`
                                                
                                                	// Reason: One-word CamelCase reason for the condition's current
                                                	// status.
                                                	// +optional
                                                	Reason string `json:"reason,omitempty"`
                                                
                                                	// Severity: How to interpret failures of this condition, one of Error,
                                                	// Warning, Info
                                                	// +optional
                                                	Severity string `json:"severity,omitempty"`
                                                
                                                	// Status: Status of the condition, one of True, False, Unknown.
                                                	Status string `json:"status,omitempty"`
                                                
                                                	// Type: Type of domain mapping condition.
                                                	Type string `json:"type,omitempty"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "LastTransitionTime")
                                                	// to unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "LastTransitionTime") to
                                                	// include in API requests with the JSON null value. By default, fields
                                                	// with empty values are omitted from API requests. However, any field
                                                	// with an empty value appearing in NullFields will be sent to the
                                                	// server as null. It is an error if a field in this list has a
                                                	// non-empty value. This may be used to include null fields in Patch
                                                	// requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  DomainMappingCondition: DomainMappingCondition contains state information for a DomainMapping.

                                                  func (*DomainMappingCondition) MarshalJSON

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

                                                  type DomainMappingSpec

                                                  type DomainMappingSpec struct {
                                                  	// CertificateMode: The mode of the certificate.
                                                  	//
                                                  	// Possible values:
                                                  	//   "CERTIFICATE_MODE_UNSPECIFIED"
                                                  	//   "NONE" - Do not provision an HTTPS certificate.
                                                  	//   "AUTOMATIC" - Automatically provisions an HTTPS certificate via
                                                  	// LetsEncrypt.
                                                  	CertificateMode string `json:"certificateMode,omitempty"`
                                                  
                                                  	// ForceOverride: If set, the mapping will override any mapping set
                                                  	// before this spec was set.
                                                  	// It is recommended that the user leaves this empty to receive an
                                                  	// error
                                                  	// warning about a potential conflict and only set it once the
                                                  	// respective UI
                                                  	// has given such a warning.
                                                  	ForceOverride bool `json:"forceOverride,omitempty"`
                                                  
                                                  	// RouteName: The name of the Knative Route that this DomainMapping
                                                  	// applies to.
                                                  	// The route must exist.
                                                  	RouteName string `json:"routeName,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "CertificateMode") to
                                                  	// unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "CertificateMode") to
                                                  	// include in API requests with the JSON null value. By default, fields
                                                  	// with empty values are omitted from API requests. However, any field
                                                  	// with an empty value appearing in NullFields will be sent to the
                                                  	// server as null. It is an error if a field in this list has a
                                                  	// non-empty value. This may be used to include null fields in Patch
                                                  	// requests.
                                                  	NullFields []string `json:"-"`
                                                  }

                                                    DomainMappingSpec: The desired state of the Domain Mapping.

                                                    func (*DomainMappingSpec) MarshalJSON

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

                                                    type DomainMappingStatus

                                                    type DomainMappingStatus struct {
                                                    	// Conditions: Array of observed DomainMappingConditions, indicating the
                                                    	// current state
                                                    	// of the DomainMapping.
                                                    	Conditions []*DomainMappingCondition `json:"conditions,omitempty"`
                                                    
                                                    	// MappedRouteName: The name of the route that the mapping currently
                                                    	// points to.
                                                    	MappedRouteName string `json:"mappedRouteName,omitempty"`
                                                    
                                                    	// ObservedGeneration: ObservedGeneration is the 'Generation' of the
                                                    	// DomainMapping that
                                                    	// was last processed by the controller.
                                                    	//
                                                    	// Clients polling for completed reconciliation should poll
                                                    	// until
                                                    	// observedGeneration = metadata.generation and the Ready condition's
                                                    	// status
                                                    	// is True or False.
                                                    	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
                                                    
                                                    	// ResourceRecords: The resource records required to configure this
                                                    	// domain mapping. These
                                                    	// records must be added to the domain's DNS configuration in order
                                                    	// to
                                                    	// serve the application via this domain mapping.
                                                    	ResourceRecords []*ResourceRecord `json:"resourceRecords,omitempty"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "Conditions") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "Conditions") to include in
                                                    	// API requests with the JSON null value. By default, fields with empty
                                                    	// values are omitted from API requests. However, any field with an
                                                    	// empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

                                                      DomainMappingStatus: The current state of the Domain Mapping.

                                                      func (*DomainMappingStatus) MarshalJSON

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

                                                      type Empty

                                                      type Empty struct {
                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                      	// server.
                                                      	googleapi.ServerResponse `json:"-"`
                                                      }

                                                        Empty: A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:

                                                        service Foo {
                                                          rpc Bar(google.protobuf.Empty) returns
                                                        

                                                        (google.protobuf.Empty);

                                                        }
                                                        

                                                        The JSON representation for `Empty` is empty JSON object `{}`.

                                                        type EnvFromSource

                                                        type EnvFromSource struct {
                                                        	// ConfigMapRef: The ConfigMap to select from
                                                        	// +optional
                                                        	ConfigMapRef *ConfigMapEnvSource `json:"configMapRef,omitempty"`
                                                        
                                                        	// Prefix: An optional identifier to prepend to each key in the
                                                        	// ConfigMap. Must be a
                                                        	// C_IDENTIFIER. +optional
                                                        	Prefix string `json:"prefix,omitempty"`
                                                        
                                                        	// SecretRef: The Secret to select from
                                                        	// +optional
                                                        	SecretRef *SecretEnvSource `json:"secretRef,omitempty"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "ConfigMapRef") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "ConfigMapRef") to include
                                                        	// in API requests with the JSON null value. By default, fields with
                                                        	// empty values are omitted from API requests. However, any field with
                                                        	// an empty value appearing in NullFields will be sent to the server as
                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                        	// This may be used to include null fields in Patch requests.
                                                        	NullFields []string `json:"-"`
                                                        }

                                                          EnvFromSource: EnvFromSource represents the source of a set of ConfigMaps

                                                          func (*EnvFromSource) MarshalJSON

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

                                                          type EnvVar

                                                          type EnvVar struct {
                                                          	// Name: Name of the environment variable. Must be a C_IDENTIFIER.
                                                          	Name string `json:"name,omitempty"`
                                                          
                                                          	// Value: Variable references $(VAR_NAME) are expanded
                                                          	// using the previous defined environment variables in the container
                                                          	// and
                                                          	// any route environment variables. If a variable cannot be
                                                          	// resolved,
                                                          	// the reference in the input string will be unchanged. The
                                                          	// $(VAR_NAME)
                                                          	// syntax can be escaped with a double $$, ie: $$(VAR_NAME).
                                                          	// Escaped
                                                          	// references will never be expanded, regardless of whether the
                                                          	// variable
                                                          	// exists or not.
                                                          	// Defaults to "".
                                                          	// +optional
                                                          	Value string `json:"value,omitempty"`
                                                          
                                                          	// ValueFrom: Cloud Run fully managed: not supported
                                                          	//
                                                          	// Cloud Run on GKE: supported
                                                          	//
                                                          	// Source for the environment variable's value. Cannot be used if value
                                                          	// is not
                                                          	// empty. +optional
                                                          	ValueFrom *EnvVarSource `json:"valueFrom,omitempty"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g. "Name") to
                                                          	// unconditionally include in API requests. By default, fields with
                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                          	// server regardless of whether the field is empty or not. This may be
                                                          	// used to include empty fields in Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "Name") to include in API
                                                          	// requests with the JSON null value. By default, fields with empty
                                                          	// values are omitted from API requests. However, any field with an
                                                          	// empty value appearing in NullFields will be sent to the server as
                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                          	// This may be used to include null fields in Patch requests.
                                                          	NullFields []string `json:"-"`
                                                          }

                                                            EnvVar: EnvVar represents an environment variable present in a Container.

                                                            func (*EnvVar) MarshalJSON

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

                                                            type EnvVarSource

                                                            type EnvVarSource struct {
                                                            	// ConfigMapKeyRef: Cloud Run fully managed: not supported
                                                            	//
                                                            	// Cloud Run on GKE: supported
                                                            	//
                                                            	// Selects a key of a ConfigMap.
                                                            	// +optional
                                                            	ConfigMapKeyRef *ConfigMapKeySelector `json:"configMapKeyRef,omitempty"`
                                                            
                                                            	// SecretKeyRef: Cloud Run fully managed: not supported
                                                            	//
                                                            	// Cloud Run on GKE: supported
                                                            	//
                                                            	// Selects a key of a secret in the pod's namespace
                                                            	// +optional
                                                            	SecretKeyRef *SecretKeySelector `json:"secretKeyRef,omitempty"`
                                                            
                                                            	// ForceSendFields is a list of field names (e.g. "ConfigMapKeyRef") to
                                                            	// unconditionally include in API requests. By default, fields with
                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                            	// server regardless of whether the field is empty or not. This may be
                                                            	// used to include empty fields in Patch requests.
                                                            	ForceSendFields []string `json:"-"`
                                                            
                                                            	// NullFields is a list of field names (e.g. "ConfigMapKeyRef") to
                                                            	// include in API requests with the JSON null value. By default, fields
                                                            	// with empty values are omitted from API requests. However, any field
                                                            	// with an empty value appearing in NullFields will be sent to the
                                                            	// server as null. It is an error if a field in this list has a
                                                            	// non-empty value. This may be used to include null fields in Patch
                                                            	// requests.
                                                            	NullFields []string `json:"-"`
                                                            }

                                                              EnvVarSource: Cloud Run fully managed: not supported

                                                              Cloud Run on GKE: supported

                                                              EnvVarSource represents a source for the value of an EnvVar.

                                                              func (*EnvVarSource) MarshalJSON

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

                                                              type EventType

                                                              type EventType struct {
                                                              	// ApiVersion: The API version for this call such as
                                                              	// "eventing.knative.dev/v1alpha1".
                                                              	ApiVersion string `json:"apiVersion,omitempty"`
                                                              
                                                              	// Kind: The kind of resource, in this case "EventType".
                                                              	Kind string `json:"kind,omitempty"`
                                                              
                                                              	// Metadata: Metadata associated with this EventType.
                                                              	Metadata *ObjectMeta `json:"metadata,omitempty"`
                                                              
                                                              	// Spec: Spec defines the desired state of the EventType.
                                                              	Spec *EventTypeSpec `json:"spec,omitempty"`
                                                              
                                                              	// ServerResponse contains the HTTP response code and headers from the
                                                              	// server.
                                                              	googleapi.ServerResponse `json:"-"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                              	// API requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                              func (*EventType) MarshalJSON

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

                                                              type EventTypeImporter

                                                              type EventTypeImporter struct {
                                                              	// ApiVersion: The API version of the importer CRD.
                                                              	ApiVersion string `json:"apiVersion,omitempty"`
                                                              
                                                              	// Kind: The kind of the importer CRD.
                                                              	Kind string `json:"kind,omitempty"`
                                                              
                                                              	// Parameters: Parameters required to create an importer for the
                                                              	// EventType.
                                                              	Parameters []*EventTypeParameter `json:"parameters,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "ApiVersion") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                              	// API requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                              func (*EventTypeImporter) MarshalJSON

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

                                                              type EventTypeParameter

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

                                                              func (*EventTypeParameter) MarshalJSON

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

                                                              type EventTypeSpec

                                                              type EventTypeSpec struct {
                                                              	// Broker: Refers to the Broker that can provide the EventType.
                                                              	Broker string `json:"broker,omitempty"`
                                                              
                                                              	// Description: Description is a string describing what the EventType is
                                                              	// about.
                                                              	// +optional
                                                              	Description string `json:"description,omitempty"`
                                                              
                                                              	// Importer: The importer that provides this EventType to the eventing
                                                              	// mesh.
                                                              	Importer *EventTypeImporter `json:"importer,omitempty"`
                                                              
                                                              	// Schema: Schema is a URI with the EventType schema. It may be a JSON
                                                              	// schema, a
                                                              	// protobuf schema, etc.
                                                              	// +optional
                                                              	Schema string `json:"schema,omitempty"`
                                                              
                                                              	// Source: Source is a valid URI. Refers to the CloudEvent source as it
                                                              	// enters into
                                                              	// the eventing mesh.
                                                              	Source string `json:"source,omitempty"`
                                                              
                                                              	// Type: Type is authoritative. This refers to the CloudEvent type as it
                                                              	// enters
                                                              	// into the eventing mesh.
                                                              	Type string `json:"type,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "Broker") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "Broker") to include in API
                                                              	// requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                              func (*EventTypeSpec) MarshalJSON

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

                                                              type ExecAction

                                                              type ExecAction struct {
                                                              	// Command: Command is the command line to execute inside the container,
                                                              	// the working
                                                              	// directory for the command  is root ('/') in the container's
                                                              	// filesystem. The
                                                              	// command is simply exec'd, it is not run inside a shell, so
                                                              	// traditional
                                                              	// shell instructions ('|', etc) won't work. To use a shell, you need
                                                              	// to
                                                              	// explicitly call out to that shell. Exit status of 0 is treated
                                                              	// as
                                                              	// live/healthy and non-zero is unhealthy. +optional
                                                              	Command string `json:"command,omitempty"`
                                                              
                                                              	// ForceSendFields is a list of field names (e.g. "Command") to
                                                              	// unconditionally include in API requests. By default, fields with
                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                              	// server regardless of whether the field is empty or not. This may be
                                                              	// used to include empty fields in Patch requests.
                                                              	ForceSendFields []string `json:"-"`
                                                              
                                                              	// NullFields is a list of field names (e.g. "Command") to include in
                                                              	// API requests with the JSON null value. By default, fields with empty
                                                              	// values are omitted from API requests. However, any field with an
                                                              	// empty value appearing in NullFields will be sent to the server as
                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                              	// This may be used to include null fields in Patch requests.
                                                              	NullFields []string `json:"-"`
                                                              }

                                                                ExecAction: ExecAction describes a "run in container" action.

                                                                func (*ExecAction) MarshalJSON

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

                                                                type Expr

                                                                type Expr struct {
                                                                	// Description: An 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.
                                                                	//
                                                                	// The application context of the containing message determines
                                                                	// which
                                                                	// well-known feature set of CEL is supported.
                                                                	Expression string `json:"expression,omitempty"`
                                                                
                                                                	// Location: An 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: An 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 values are omitted from API requests. However, any non-pointer,
                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                	// server regardless of whether the field is empty or not. This may be
                                                                	// used to include empty fields in Patch requests.
                                                                	ForceSendFields []string `json:"-"`
                                                                
                                                                	// NullFields is a list of field names (e.g. "Description") to include
                                                                	// in API requests with the JSON null value. By default, fields with
                                                                	// empty values are omitted from API requests. However, any field with
                                                                	// an empty value appearing in NullFields will be sent to the server as
                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                	// This may be used to include null fields in Patch requests.
                                                                	NullFields []string `json:"-"`
                                                                }

                                                                  Expr: Represents an expression text. Example:

                                                                  title: "User account presence"
                                                                  description: "Determines whether the request has a user account"
                                                                  expression: "size(request.user) > 0"
                                                                  

                                                                  func (*Expr) MarshalJSON

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

                                                                  type HTTPGetAction

                                                                  type HTTPGetAction struct {
                                                                  	// Host: Host name to connect to, defaults to the pod IP. You probably
                                                                  	// want to set
                                                                  	// "Host" in httpHeaders instead.
                                                                  	// +optional
                                                                  	Host string `json:"host,omitempty"`
                                                                  
                                                                  	// HttpHeaders: Custom headers to set in the request. HTTP allows
                                                                  	// repeated headers.
                                                                  	// +optional
                                                                  	HttpHeaders []*HTTPHeader `json:"httpHeaders,omitempty"`
                                                                  
                                                                  	// Path: Path to access on the HTTP server.
                                                                  	// +optional
                                                                  	Path string `json:"path,omitempty"`
                                                                  
                                                                  	// Port: Name or number of the port to access on the container.
                                                                  	// Number must be in the range 1 to 65535.
                                                                  	// Name must be an IANA_SVC_NAME.
                                                                  	Port *IntOrString `json:"port,omitempty"`
                                                                  
                                                                  	// Scheme: Scheme to use for connecting to the host.
                                                                  	// Defaults to HTTP.
                                                                  	// +optional
                                                                  	Scheme string `json:"scheme,omitempty"`
                                                                  
                                                                  	// ForceSendFields is a list of field names (e.g. "Host") to
                                                                  	// unconditionally include in API requests. By default, fields with
                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                  	// used to include empty fields in Patch requests.
                                                                  	ForceSendFields []string `json:"-"`
                                                                  
                                                                  	// NullFields is a list of field names (e.g. "Host") to include in API
                                                                  	// requests with the JSON null value. By default, fields with empty
                                                                  	// values are omitted from API requests. However, any field with an
                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                  	// This may be used to include null fields in Patch requests.
                                                                  	NullFields []string `json:"-"`
                                                                  }

                                                                    HTTPGetAction: HTTPGetAction describes an action based on HTTP Get requests.

                                                                    func (*HTTPGetAction) MarshalJSON

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

                                                                    type HTTPHeader

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

                                                                      HTTPHeader: HTTPHeader describes a custom header to be used in HTTP probes

                                                                      func (*HTTPHeader) MarshalJSON

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

                                                                      type Handler

                                                                      type Handler struct {
                                                                      	// Exec: One and only one of the following should be specified.
                                                                      	// Exec specifies the action to take.
                                                                      	// +optional
                                                                      	Exec *ExecAction `json:"exec,omitempty"`
                                                                      
                                                                      	// HttpGet: HTTPGet specifies the http request to perform.
                                                                      	// +optional
                                                                      	HttpGet *HTTPGetAction `json:"httpGet,omitempty"`
                                                                      
                                                                      	// TcpSocket: TCPSocket specifies an action involving a TCP port.
                                                                      	// TCP hooks not yet supported
                                                                      	TcpSocket *TCPSocketAction `json:"tcpSocket,omitempty"`
                                                                      
                                                                      	// ForceSendFields is a list of field names (e.g. "Exec") to
                                                                      	// unconditionally include in API requests. By default, fields with
                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                      	// used to include empty fields in Patch requests.
                                                                      	ForceSendFields []string `json:"-"`
                                                                      
                                                                      	// NullFields is a list of field names (e.g. "Exec") to include in API
                                                                      	// requests with the JSON null value. By default, fields with empty
                                                                      	// values are omitted from API requests. However, any field with an
                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                      	// This may be used to include null fields in Patch requests.
                                                                      	NullFields []string `json:"-"`
                                                                      }

                                                                        Handler: Handler defines a specific action that should be taken

                                                                        func (*Handler) MarshalJSON

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

                                                                        type Initializer

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

                                                                          Initializer: Initializer is information about an initializer that has not yet completed.

                                                                          func (*Initializer) MarshalJSON

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

                                                                          type Initializers

                                                                          type Initializers struct {
                                                                          	// Pending: Pending is a list of initializers that must execute in order
                                                                          	// before this
                                                                          	// object is visible. When the last pending initializer is removed, and
                                                                          	// no
                                                                          	// failing result is set, the initializers struct will be set to nil and
                                                                          	// the
                                                                          	// object is considered as initialized and visible to all
                                                                          	// clients.
                                                                          	// +patchMergeKey=name
                                                                          	// +patchStrategy=merge
                                                                          	Pending []*Initializer `json:"pending,omitempty"`
                                                                          
                                                                          	// ForceSendFields is a list of field names (e.g. "Pending") to
                                                                          	// unconditionally include in API requests. By default, fields with
                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                          	// used to include empty fields in Patch requests.
                                                                          	ForceSendFields []string `json:"-"`
                                                                          
                                                                          	// NullFields is a list of field names (e.g. "Pending") to include in
                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                          	// values are omitted from API requests. However, any field with an
                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                          	// This may be used to include null fields in Patch requests.
                                                                          	NullFields []string `json:"-"`
                                                                          }

                                                                            Initializers: Initializers tracks the progress of initialization.

                                                                            func (*Initializers) MarshalJSON

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

                                                                            type IntOrString

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

                                                                              IntOrString: IntOrString is a type that can hold an int32 or a string. When used in JSON or YAML marshalling and unmarshalling, it produces or consumes the inner type. This allows you to have, for example, a JSON field that can accept a name or number.

                                                                              func (*IntOrString) MarshalJSON

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

                                                                              type KeyToPath

                                                                              type KeyToPath struct {
                                                                              	// Key: The key to project.
                                                                              	Key string `json:"key,omitempty"`
                                                                              
                                                                              	// Mode: Mode bits to use on this file, must be a value between 0 and
                                                                              	// 0777. If not
                                                                              	// specified, the volume defaultMode will be used. This might be in
                                                                              	// conflict
                                                                              	// with other options that affect the file mode, like fsGroup, and the
                                                                              	// result
                                                                              	// can be other mode bits set. +optional
                                                                              	Mode int64 `json:"mode,omitempty"`
                                                                              
                                                                              	// Path: The relative path of the file to map the key to.
                                                                              	// May not be an absolute path.
                                                                              	// May not contain the path element '..'.
                                                                              	// May not start with the string '..'.
                                                                              	Path string `json:"path,omitempty"`
                                                                              
                                                                              	// ForceSendFields is a list of field names (e.g. "Key") to
                                                                              	// unconditionally include in API requests. By default, fields with
                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                              	// used to include empty fields in Patch requests.
                                                                              	ForceSendFields []string `json:"-"`
                                                                              
                                                                              	// NullFields is a list of field names (e.g. "Key") to include in API
                                                                              	// requests with the JSON null value. By default, fields with empty
                                                                              	// values are omitted from API requests. However, any field with an
                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                              	// This may be used to include null fields in Patch requests.
                                                                              	NullFields []string `json:"-"`
                                                                              }

                                                                                KeyToPath: Maps a string key to a path within a volume.

                                                                                func (*KeyToPath) MarshalJSON

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

                                                                                type Lifecycle

                                                                                type Lifecycle struct {
                                                                                	// PostStart: PostStart is called immediately after a container is
                                                                                	// created. If the
                                                                                	// handler fails, the container is terminated and restarted according to
                                                                                	// its
                                                                                	// restart policy. Other management of the container blocks until the
                                                                                	// hook
                                                                                	// completes. More
                                                                                	// info:
                                                                                	// https://kubernetes.io/docs/concepts/containers/container-lifecyc
                                                                                	// le-hooks/#container-hooks
                                                                                	// +optional
                                                                                	PostStart *Handler `json:"postStart,omitempty"`
                                                                                
                                                                                	// PreStop: PreStop is called immediately before a container is
                                                                                	// terminated.
                                                                                	// The container is terminated after the handler completes.
                                                                                	// The reason for termination is passed to the handler.
                                                                                	// Regardless of the outcome of the handler, the container is
                                                                                	// eventually
                                                                                	// terminated. Other management of the container blocks until the
                                                                                	// hook
                                                                                	// completes. More
                                                                                	// info:
                                                                                	// https://kubernetes.io/docs/concepts/containers/container-lifecyc
                                                                                	// le-hooks/#container-hooks
                                                                                	// +optional
                                                                                	PreStop *Handler `json:"preStop,omitempty"`
                                                                                
                                                                                	// ForceSendFields is a list of field names (e.g. "PostStart") to
                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                	// used to include empty fields in Patch requests.
                                                                                	ForceSendFields []string `json:"-"`
                                                                                
                                                                                	// NullFields is a list of field names (e.g. "PostStart") to include in
                                                                                	// API requests with the JSON null value. By default, fields with empty
                                                                                	// values are omitted from API requests. However, any field with an
                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                	// This may be used to include null fields in Patch requests.
                                                                                	NullFields []string `json:"-"`
                                                                                }

                                                                                  Lifecycle: Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.

                                                                                  func (*Lifecycle) MarshalJSON

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

                                                                                  type ListAuthorizedDomainsResponse

                                                                                  type ListAuthorizedDomainsResponse struct {
                                                                                  	// Domains: The authorized domains belonging to the user.
                                                                                  	Domains []*AuthorizedDomain `json:"domains,omitempty"`
                                                                                  
                                                                                  	// NextPageToken: Continuation token for fetching 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 values are omitted from API requests. However, any non-pointer,
                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                  	// used to include empty fields in Patch requests.
                                                                                  	ForceSendFields []string `json:"-"`
                                                                                  
                                                                                  	// NullFields is a list of field names (e.g. "Domains") to include in
                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                  	NullFields []string `json:"-"`
                                                                                  }

                                                                                    ListAuthorizedDomainsResponse: A list of Authorized Domains.

                                                                                    func (*ListAuthorizedDomainsResponse) MarshalJSON

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

                                                                                    type ListCloudAuditLogsResponse

                                                                                    type ListCloudAuditLogsResponse struct {
                                                                                    	// ApiVersion: The API version for this call such as
                                                                                    	// "events.cloud.google.com/v1alpha1".
                                                                                    	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                    
                                                                                    	// Items: List of CloudAuditLogs.
                                                                                    	Items []*CloudAuditLog `json:"items,omitempty"`
                                                                                    
                                                                                    	// Kind: The kind of this resource, in this case "CloudAuditLogList".
                                                                                    	Kind string `json:"kind,omitempty"`
                                                                                    
                                                                                    	// Metadata: Metadata associated with this CloudAuditLog list.
                                                                                    	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                    
                                                                                    	// Unreachable: Locations that could not be reached.
                                                                                    	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. "ApiVersion") to
                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                    	// used to include empty fields in Patch requests.
                                                                                    	ForceSendFields []string `json:"-"`
                                                                                    
                                                                                    	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                    	NullFields []string `json:"-"`
                                                                                    }

                                                                                      ListCloudAuditLogsResponse: ListCloudAuditLogsResponse is a list of CloudAuditLog resources.

                                                                                      func (*ListCloudAuditLogsResponse) MarshalJSON

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

                                                                                      type ListConfigurationsResponse

                                                                                      type ListConfigurationsResponse struct {
                                                                                      	// ApiVersion: The API version for this call such as
                                                                                      	// "serving.knative.dev/v1alpha1".
                                                                                      	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                      
                                                                                      	// Items: List of Configurations.
                                                                                      	Items []*Configuration `json:"items,omitempty"`
                                                                                      
                                                                                      	// Kind: The kind of this resource, in this case "ConfigurationList".
                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                      
                                                                                      	// Metadata: Metadata associated with this Configuration list.
                                                                                      	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                      
                                                                                      	// Unreachable: Locations that could not be reached.
                                                                                      	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. "ApiVersion") to
                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                      	// used to include empty fields in Patch requests.
                                                                                      	ForceSendFields []string `json:"-"`
                                                                                      
                                                                                      	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                      	NullFields []string `json:"-"`
                                                                                      }

                                                                                        ListConfigurationsResponse: ListConfigurationsResponse is a list of Configuration resources.

                                                                                        func (*ListConfigurationsResponse) MarshalJSON

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

                                                                                        type ListDomainMappingsResponse

                                                                                        type ListDomainMappingsResponse struct {
                                                                                        	// ApiVersion: The API version for this call such as
                                                                                        	// "domains.cloudrun.com/v1alpha1".
                                                                                        	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                        
                                                                                        	// Items: List of DomainMappings.
                                                                                        	Items []*DomainMapping `json:"items,omitempty"`
                                                                                        
                                                                                        	// Kind: The kind of this resource, in this case "DomainMappingList".
                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                        
                                                                                        	// Metadata: Metadata associated with this DomainMapping list.
                                                                                        	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                        
                                                                                        	// Unreachable: Locations that could not be reached.
                                                                                        	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. "ApiVersion") to
                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                        	// used to include empty fields in Patch requests.
                                                                                        	ForceSendFields []string `json:"-"`
                                                                                        
                                                                                        	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                        	NullFields []string `json:"-"`
                                                                                        }

                                                                                          ListDomainMappingsResponse: ListDomainMappingsResponse is a list of DomainMapping resources.

                                                                                          func (*ListDomainMappingsResponse) MarshalJSON

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

                                                                                          type ListEventTypesResponse

                                                                                          type ListEventTypesResponse struct {
                                                                                          	// ApiVersion: The API version for this call such as
                                                                                          	// "eventing.knative.dev/v1alpha1".
                                                                                          	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                          
                                                                                          	// Items: List of EventTypes.
                                                                                          	Items []*EventType `json:"items,omitempty"`
                                                                                          
                                                                                          	// Kind: The kind of this resource, in this case "EventTypeList".
                                                                                          	Kind string `json:"kind,omitempty"`
                                                                                          
                                                                                          	// Metadata: Metadata associated with this EventType list.
                                                                                          	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                          
                                                                                          	// Unreachable: Locations that could not be reached.
                                                                                          	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. "ApiVersion") to
                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                          	// used to include empty fields in Patch requests.
                                                                                          	ForceSendFields []string `json:"-"`
                                                                                          
                                                                                          	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                          	NullFields []string `json:"-"`
                                                                                          }

                                                                                            ListEventTypesResponse: ListEventTypesResponse is a list of EventType resources.

                                                                                            func (*ListEventTypesResponse) MarshalJSON

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

                                                                                            type ListLocationsResponse

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

                                                                                              ListLocationsResponse: The response message for Locations.ListLocations.

                                                                                              func (*ListLocationsResponse) MarshalJSON

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

                                                                                              type ListMeta

                                                                                              type ListMeta struct {
                                                                                              	// Continue: continue may be set if the user set a limit on the number
                                                                                              	// of items
                                                                                              	// returned, and indicates that the server has more data available. The
                                                                                              	// value
                                                                                              	// is opaque and may be used to issue another request to the endpoint
                                                                                              	// that
                                                                                              	// served this list to retrieve the next set of available objects.
                                                                                              	// Continuing
                                                                                              	// a list may not be possible if the server configuration has changed or
                                                                                              	// more
                                                                                              	// than a few minutes have passed. The resourceVersion field returned
                                                                                              	// when
                                                                                              	// using this continue value will be identical to the value in the
                                                                                              	// first
                                                                                              	// response.
                                                                                              	Continue string `json:"continue,omitempty"`
                                                                                              
                                                                                              	// ResourceVersion: String that identifies the server's internal version
                                                                                              	// of this object that
                                                                                              	// can be used by clients to determine when objects have changed. Value
                                                                                              	// must
                                                                                              	// be treated as opaque by clients and passed unmodified back to the
                                                                                              	// server.
                                                                                              	// Populated by the system.
                                                                                              	// Read-only.
                                                                                              	// More
                                                                                              	// info:
                                                                                              	// https://git.k8s.io/community/contributors/devel/api-conventions.
                                                                                              	// md#concurrency-control-and-consistency
                                                                                              	// +optional
                                                                                              	ResourceVersion string `json:"resourceVersion,omitempty"`
                                                                                              
                                                                                              	// SelfLink: SelfLink is a URL representing this object.
                                                                                              	// Populated by the system.
                                                                                              	// Read-only.
                                                                                              	// +optional
                                                                                              	SelfLink string `json:"selfLink,omitempty"`
                                                                                              
                                                                                              	// ForceSendFields is a list of field names (e.g. "Continue") to
                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                              	// used to include empty fields in Patch requests.
                                                                                              	ForceSendFields []string `json:"-"`
                                                                                              
                                                                                              	// NullFields is a list of field names (e.g. "Continue") to include in
                                                                                              	// API requests with the JSON null value. By default, fields with empty
                                                                                              	// values are omitted from API requests. However, any field with an
                                                                                              	// empty value appearing in NullFields will be sent to the server as
                                                                                              	// null. It is an error if a field in this list has a non-empty value.
                                                                                              	// This may be used to include null fields in Patch requests.
                                                                                              	NullFields []string `json:"-"`
                                                                                              }

                                                                                                ListMeta: ListMeta describes metadata that synthetic resources must have, including lists and various status objects. A resource may have only one of {ObjectMeta, ListMeta}.

                                                                                                func (*ListMeta) MarshalJSON

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

                                                                                                type ListPubSubsResponse

                                                                                                type ListPubSubsResponse struct {
                                                                                                	// ApiVersion: The API version for this call such as
                                                                                                	// "events.cloud.google.com/v1alpha1".
                                                                                                	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                
                                                                                                	// Items: List of PubSubs.
                                                                                                	Items []*PubSub `json:"items,omitempty"`
                                                                                                
                                                                                                	// Kind: The kind of this resource, in this case "PubSubList".
                                                                                                	Kind string `json:"kind,omitempty"`
                                                                                                
                                                                                                	// Metadata: Metadata associated with this PubSub list.
                                                                                                	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                
                                                                                                	// Unreachable: Locations that could not be reached.
                                                                                                	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. "ApiVersion") to
                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                	// used to include empty fields in Patch requests.
                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                
                                                                                                	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                	// API requests with the JSON null value. By default, fields with empty
                                                                                                	// values are omitted from API requests. However, any field with an
                                                                                                	// empty value appearing in NullFields will be sent to the server as
                                                                                                	// null. It is an error if a field in this list has a non-empty value.
                                                                                                	// This may be used to include null fields in Patch requests.
                                                                                                	NullFields []string `json:"-"`
                                                                                                }

                                                                                                  ListPubSubsResponse: ListPubSubsResponse is a list of PubSub resources.

                                                                                                  func (*ListPubSubsResponse) MarshalJSON

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

                                                                                                  type ListRevisionsResponse

                                                                                                  type ListRevisionsResponse struct {
                                                                                                  	// ApiVersion: The API version for this call such as
                                                                                                  	// "serving.knative.dev/v1alpha1".
                                                                                                  	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                  
                                                                                                  	// Items: List of Revisions.
                                                                                                  	Items []*Revision `json:"items,omitempty"`
                                                                                                  
                                                                                                  	// Kind: The kind of this resource, in this case "RevisionList".
                                                                                                  	Kind string `json:"kind,omitempty"`
                                                                                                  
                                                                                                  	// Metadata: Metadata associated with this revision list.
                                                                                                  	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                  
                                                                                                  	// Unreachable: Locations that could not be reached.
                                                                                                  	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. "ApiVersion") to
                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                  
                                                                                                  	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                  	// API requests with the JSON null value. By default, fields with empty
                                                                                                  	// values are omitted from API requests. However, any field with an
                                                                                                  	// empty value appearing in NullFields will be sent to the server as
                                                                                                  	// null. It is an error if a field in this list has a non-empty value.
                                                                                                  	// This may be used to include null fields in Patch requests.
                                                                                                  	NullFields []string `json:"-"`
                                                                                                  }

                                                                                                    ListRevisionsResponse: ListRevisionsResponse is a list of Revision resources.

                                                                                                    func (*ListRevisionsResponse) MarshalJSON

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

                                                                                                    type ListRoutesResponse

                                                                                                    type ListRoutesResponse struct {
                                                                                                    	// ApiVersion: The API version for this call such as
                                                                                                    	// "serving.knative.dev/v1alpha1".
                                                                                                    	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                    
                                                                                                    	// Items: List of Routes.
                                                                                                    	Items []*Route `json:"items,omitempty"`
                                                                                                    
                                                                                                    	// Kind: The kind of this resource, in this case always "RouteList".
                                                                                                    	Kind string `json:"kind,omitempty"`
                                                                                                    
                                                                                                    	// Metadata: Metadata associated with this Route list.
                                                                                                    	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                    
                                                                                                    	// Unreachable: Locations that could not be reached.
                                                                                                    	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. "ApiVersion") to
                                                                                                    	// unconditionally include in API requests. By default, fields with
                                                                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                    	// server regardless of whether the field is empty or not. This may be
                                                                                                    	// used to include empty fields in Patch requests.
                                                                                                    	ForceSendFields []string `json:"-"`
                                                                                                    
                                                                                                    	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                    	// API requests with the JSON null value. By default, fields with empty
                                                                                                    	// values are omitted from API requests. However, any field with an
                                                                                                    	// empty value appearing in NullFields will be sent to the server as
                                                                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                                                                    	// This may be used to include null fields in Patch requests.
                                                                                                    	NullFields []string `json:"-"`
                                                                                                    }

                                                                                                      ListRoutesResponse: ListRoutesResponse is a list of Route resources.

                                                                                                      func (*ListRoutesResponse) MarshalJSON

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

                                                                                                      type ListServicesResponse

                                                                                                      type ListServicesResponse struct {
                                                                                                      	// ApiVersion: The API version for this call such as
                                                                                                      	// "serving.knative.dev/v1alpha1".
                                                                                                      	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                      
                                                                                                      	// Items: List of Services.
                                                                                                      	Items []*Service `json:"items,omitempty"`
                                                                                                      
                                                                                                      	// Kind: The kind of this resource, in this case "ServiceList".
                                                                                                      	Kind string `json:"kind,omitempty"`
                                                                                                      
                                                                                                      	// Metadata: Metadata associated with this Service list.
                                                                                                      	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                      
                                                                                                      	// Unreachable: Locations that could not be reached.
                                                                                                      	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. "ApiVersion") to
                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                      
                                                                                                      	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                      	// API requests with the JSON null value. By default, fields with empty
                                                                                                      	// values are omitted from API requests. However, any field with an
                                                                                                      	// empty value appearing in NullFields will be sent to the server as
                                                                                                      	// null. It is an error if a field in this list has a non-empty value.
                                                                                                      	// This may be used to include null fields in Patch requests.
                                                                                                      	NullFields []string `json:"-"`
                                                                                                      }

                                                                                                        ListServicesResponse: A list of Service resources.

                                                                                                        func (*ListServicesResponse) MarshalJSON

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

                                                                                                        type ListStoragesResponse

                                                                                                        type ListStoragesResponse struct {
                                                                                                        	// ApiVersion: The API version for this call such as
                                                                                                        	// "events.cloud.google.com/v1alpha1".
                                                                                                        	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                        
                                                                                                        	// Items: List of Storages.
                                                                                                        	Items []*Storage `json:"items,omitempty"`
                                                                                                        
                                                                                                        	// Kind: The kind of this resource, in this case "StorageList".
                                                                                                        	Kind string `json:"kind,omitempty"`
                                                                                                        
                                                                                                        	// Metadata: Metadata associated with this Storage list.
                                                                                                        	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                        
                                                                                                        	// Unreachable: Locations that could not be reached.
                                                                                                        	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. "ApiVersion") to
                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                        
                                                                                                        	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                        	// API requests with the JSON null value. By default, fields with empty
                                                                                                        	// values are omitted from API requests. However, any field with an
                                                                                                        	// empty value appearing in NullFields will be sent to the server as
                                                                                                        	// null. It is an error if a field in this list has a non-empty value.
                                                                                                        	// This may be used to include null fields in Patch requests.
                                                                                                        	NullFields []string `json:"-"`
                                                                                                        }

                                                                                                          ListStoragesResponse: ListStoragesResponse is a list of Storage resources.

                                                                                                          func (*ListStoragesResponse) MarshalJSON

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

                                                                                                          type ListTriggersResponse

                                                                                                          type ListTriggersResponse struct {
                                                                                                          	// ApiVersion: The API version for this call such as
                                                                                                          	// "eventing.knative.dev/v1alpha1".
                                                                                                          	ApiVersion string `json:"apiVersion,omitempty"`
                                                                                                          
                                                                                                          	// Items: List of Triggers.
                                                                                                          	Items []*Trigger `json:"items,omitempty"`
                                                                                                          
                                                                                                          	// Kind: The kind of this resource, in this case "TriggerList".
                                                                                                          	Kind string `json:"kind,omitempty"`
                                                                                                          
                                                                                                          	// Metadata: Metadata associated with this Trigger list.
                                                                                                          	Metadata *ListMeta `json:"metadata,omitempty"`
                                                                                                          
                                                                                                          	// Unreachable: Locations that could not be reached.
                                                                                                          	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. "ApiVersion") to
                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                          
                                                                                                          	// NullFields is a list of field names (e.g. "ApiVersion") to include in
                                                                                                          	// API requests with the JSON null value. By default, fields with empty
                                                                                                          	// values are omitted from API requests. However, any field with an
                                                                                                          	// empty value appearing in NullFields will be sent to the server as
                                                                                                          	// null. It is an error if a field in this list has a non-empty value.
                                                                                                          	// This may be used to include null fields in Patch requests.
                                                                                                          	NullFields []string `json:"-"`
                                                                                                          }

                                                                                                            ListTriggersResponse: ListTriggersResponse is a list of Trigger resources.

                                                                                                            func (*ListTriggersResponse) MarshalJSON

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

                                                                                                            type LocalObjectReference

                                                                                                            type LocalObjectReference struct {
                                                                                                            	// Name: Name of the referent.
                                                                                                            	// More
                                                                                                            	// info:
                                                                                                            	// https://kubernetes.io/docs/concepts/overview/working-with-object
                                                                                                            	// s/names/#names
                                                                                                            	Name string `json:"name,omitempty"`
                                                                                                            
                                                                                                            	// ForceSendFields is a list of field names (e.g. "Name") to
                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                            
                                                                                                            	// NullFields is a list of field names (e.g. "Name") to include in API
                                                                                                            	// requests with the JSON null value. By default, fields with empty
                                                                                                            	// values are omitted from API requests. However, any field with an
                                                                                                            	// empty value appearing in NullFields will be sent to the server as
                                                                                                            	// null. It is an error if a field in this list has a non-empty value.
                                                                                                            	// This may be used to include null fields in Patch requests.
                                                                                                            	NullFields []string `json:"-"`
                                                                                                            }

                                                                                                              LocalObjectReference: LocalObjectReference contains enough information to let you locate the referenced object inside the same namespace.

                                                                                                              func (*LocalObjectReference) MarshalJSON

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

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

                                                                                                                Location: A resource that represents Google Cloud Platform location.

                                                                                                                func (*Location) MarshalJSON

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

                                                                                                                type NamespacesAuthorizeddomainsListCall

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

                                                                                                                func (*NamespacesAuthorizeddomainsListCall) Context

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

                                                                                                                  func (*NamespacesAuthorizeddomainsListCall) Do

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

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

                                                                                                                      func (*NamespacesAuthorizeddomainsListCall) Header

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

                                                                                                                        func (*NamespacesAuthorizeddomainsListCall) IfNoneMatch

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

                                                                                                                          func (*NamespacesAuthorizeddomainsListCall) PageSize

                                                                                                                            PageSize sets the optional parameter "pageSize": Maximum results to return per page.

                                                                                                                            func (*NamespacesAuthorizeddomainsListCall) PageToken

                                                                                                                              PageToken sets the optional parameter "pageToken": Continuation token for fetching the next page of results.

                                                                                                                              func (*NamespacesAuthorizeddomainsListCall) Pages

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

                                                                                                                                type NamespacesAuthorizeddomainsService

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

                                                                                                                                func NewNamespacesAuthorizeddomainsService

                                                                                                                                func NewNamespacesAuthorizeddomainsService(s *APIService) *NamespacesAuthorizeddomainsService

                                                                                                                                func (*NamespacesAuthorizeddomainsService) List

                                                                                                                                  List: RPC to list authorized domains.

                                                                                                                                  type NamespacesCloudauditlogsCreateCall

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

                                                                                                                                  func (*NamespacesCloudauditlogsCreateCall) Context

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

                                                                                                                                    func (*NamespacesCloudauditlogsCreateCall) Do

                                                                                                                                      Do executes the "run.namespaces.cloudauditlogs.create" call. Exactly one of *CloudAuditLog or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *CloudAuditLog.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 (*NamespacesCloudauditlogsCreateCall) Fields

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

                                                                                                                                        func (*NamespacesCloudauditlogsCreateCall) Header

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

                                                                                                                                          type NamespacesCloudauditlogsDeleteCall

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

                                                                                                                                          func (*NamespacesCloudauditlogsDeleteCall) ApiVersion

                                                                                                                                            ApiVersion sets the optional parameter "apiVersion": Cloud Run currently ignores this parameter.

                                                                                                                                            func (*NamespacesCloudauditlogsDeleteCall) Context

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

                                                                                                                                              func (*NamespacesCloudauditlogsDeleteCall) Do

                                                                                                                                                Do executes the "run.namespaces.cloudauditlogs.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.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 (*NamespacesCloudauditlogsDeleteCall) Fields

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

                                                                                                                                                  func (*NamespacesCloudauditlogsDeleteCall) Header

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

                                                                                                                                                    func (*NamespacesCloudauditlogsDeleteCall) Kind

                                                                                                                                                      Kind sets the optional parameter "kind": Cloud Run currently ignores this parameter.

                                                                                                                                                      func (*NamespacesCloudauditlogsDeleteCall) PropagationPolicy

                                                                                                                                                      func (c *NamespacesCloudauditlogsDeleteCall) PropagationPolicy(propagationPolicy string) *NamespacesCloudauditlogsDeleteCall

                                                                                                                                                        PropagationPolicy sets the optional parameter "propagationPolicy": Specifies the propagation policy of delete. Cloud Run currently ignores this setting, and deletes in the background. Please see kubernetes.io/docs/concepts/workloads/controllers/garbage-collecti on/ for more information.

                                                                                                                                                        type NamespacesCloudauditlogsGetCall

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

                                                                                                                                                        func (*NamespacesCloudauditlogsGetCall) Context

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

                                                                                                                                                          func (*NamespacesCloudauditlogsGetCall) Do

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

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

                                                                                                                                                              func (*NamespacesCloudauditlogsGetCall) Header

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

                                                                                                                                                                func (*NamespacesCloudauditlogsGetCall) IfNoneMatch

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

                                                                                                                                                                  type NamespacesCloudauditlogsListCall

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

                                                                                                                                                                  func (*NamespacesCloudauditlogsListCall) Context

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

                                                                                                                                                                    func (*NamespacesCloudauditlogsListCall) Continue

                                                                                                                                                                      Continue sets the optional parameter "continue": Optional encoded string to continue paging.

                                                                                                                                                                      func (*NamespacesCloudauditlogsListCall) Do

                                                                                                                                                                        Do executes the "run.namespaces.cloudauditlogs.list" call. Exactly one of *ListCloudAuditLogsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListCloudAuditLogsResponse.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 (*NamespacesCloudauditlogsListCall) FieldSelector

                                                                                                                                                                          FieldSelector sets the optional parameter "fieldSelector": Allows to filter resources based on a specific value for a field name. Send this in a query string format. i.e. 'metadata.name%3Dlorem'. Not currently used by Cloud Run.

                                                                                                                                                                          func (*NamespacesCloudauditlogsListCall) Fields

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

                                                                                                                                                                            func (*NamespacesCloudauditlogsListCall) Header

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

                                                                                                                                                                              func (*NamespacesCloudauditlogsListCall) IfNoneMatch

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

                                                                                                                                                                                func (*NamespacesCloudauditlogsListCall) IncludeUninitialized

                                                                                                                                                                                func (c *NamespacesCloudauditlogsListCall) IncludeUninitialized(includeUninitialized bool) *NamespacesCloudauditlogsListCall

                                                                                                                                                                                  IncludeUninitialized sets the optional parameter "includeUninitialized": Not currently used by Cloud Run.

                                                                                                                                                                                  func (*NamespacesCloudauditlogsListCall) LabelSelector

                                                                                                                                                                                    LabelSelector sets the optional parameter "labelSelector": Allows to filter resources based on a label. Supported operations are =, !=, exists, in, and notIn.

                                                                                                                                                                                    func (*NamespacesCloudauditlogsListCall) Limit

                                                                                                                                                                                      Limit sets the optional parameter "limit": The maximum number of records that should be returned.

                                                                                                                                                                                      func (*NamespacesCloudauditlogsListCall) ResourceVersion

                                                                                                                                                                                      func (c *NamespacesCloudauditlogsListCall) ResourceVersion(resourceVersion string) *NamespacesCloudauditlogsListCall

                                                                                                                                                                                        ResourceVersion sets the optional parameter "resourceVersion": The baseline resource version from which the list or watch operation should start. Not currently used by Cloud Run.

                                                                                                                                                                                        func (*NamespacesCloudauditlogsListCall) Watch

                                                                                                                                                                                          Watch sets the optional parameter "watch": Flag that indicates that the client expects to watch this resource as well. Not currently used by Cloud Run.

                                                                                                                                                                                          type NamespacesCloudauditlogsReplaceCloudAuditLogCall

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

                                                                                                                                                                                          func (*NamespacesCloudauditlogsReplaceCloudAuditLogCall) Context

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

                                                                                                                                                                                            func (*NamespacesCloudauditlogsReplaceCloudAuditLogCall) Do

                                                                                                                                                                                              Do executes the "run.namespaces.cloudauditlogs.replaceCloudAuditLog" call. Exactly one of *CloudAuditLog or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *CloudAuditLog.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 (*NamespacesCloudauditlogsReplaceCloudAuditLogCall) Fields

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

                                                                                                                                                                                                func (*NamespacesCloudauditlogsReplaceCloudAuditLogCall) Header

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

                                                                                                                                                                                                  type NamespacesCloudauditlogsService

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

                                                                                                                                                                                                  func NewNamespacesCloudauditlogsService

                                                                                                                                                                                                  func NewNamespacesCloudauditlogsService(s *APIService) *NamespacesCloudauditlogsService

                                                                                                                                                                                                  func (*NamespacesCloudauditlogsService) Create

                                                                                                                                                                                                    Create: Creates a new cloudauditlog.

                                                                                                                                                                                                    func (*NamespacesCloudauditlogsService) Delete

                                                                                                                                                                                                      Delete: Rpc to delete a cloudauditlog.

                                                                                                                                                                                                      func (*NamespacesCloudauditlogsService) Get

                                                                                                                                                                                                        Get: Rpc to get information about a cloudauditlog.

                                                                                                                                                                                                        func (*NamespacesCloudauditlogsService) List

                                                                                                                                                                                                          List: Rpc to list cloudauditlogs.

                                                                                                                                                                                                          func (*NamespacesCloudauditlogsService) ReplaceCloudAuditLog

                                                                                                                                                                                                            ReplaceCloudAuditLog: Rpc to replace a cloudauditlog.

                                                                                                                                                                                                            Only the spec and metadata labels and annotations are modifiable. After the Update request, Cloud Run will work to make the 'status' match the requested 'spec'.

                                                                                                                                                                                                            May provide metadata.resourceVersion to enforce update from last read for optimistic concurrency control.

                                                                                                                                                                                                            type NamespacesConfigurationsGetCall

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

                                                                                                                                                                                                            func (*NamespacesConfigurationsGetCall) Context

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

                                                                                                                                                                                                              func (*NamespacesConfigurationsGetCall) Do

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

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

                                                                                                                                                                                                                  func (*NamespacesConfigurationsGetCall) Header

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

                                                                                                                                                                                                                    func (*NamespacesConfigurationsGetCall) IfNoneMatch

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

                                                                                                                                                                                                                      type NamespacesConfigurationsListCall

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

                                                                                                                                                                                                                      func (*NamespacesConfigurationsListCall) Context

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

                                                                                                                                                                                                                        func (*NamespacesConfigurationsListCall) Continue

                                                                                                                                                                                                                          Continue sets the optional parameter "continue": Optional encoded string to continue paging.

                                                                                                                                                                                                                          func (*NamespacesConfigurationsListCall) Do

                                                                                                                                                                                                                            Do executes the "run.namespaces.configurations.list" call. Exactly one of *ListConfigurationsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListConfigurationsResponse.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 (*NamespacesConfigurationsListCall) FieldSelector

                                                                                                                                                                                                                              FieldSelector sets the optional parameter "fieldSelector": Allows to filter resources based on a specific value for a field name. Send this in a query string format. i.e. 'metadata.name%3Dlorem'. Not currently used by Cloud Run.

                                                                                                                                                                                                                              func (*NamespacesConfigurationsListCall) Fields

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

                                                                                                                                                                                                                                func (*NamespacesConfigurationsListCall) Header

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

                                                                                                                                                                                                                                  func (*NamespacesConfigurationsListCall) IfNoneMatch

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

                                                                                                                                                                                                                                    func (*NamespacesConfigurationsListCall) IncludeUninitialized

                                                                                                                                                                                                                                    func (c *NamespacesConfigurationsListCall) IncludeUninitialized(includeUninitialized bool) *NamespacesConfigurationsListCall