Source file src/google.golang.org/api/runtimeconfig/v1beta1/runtimeconfig-gen.go

Documentation: google.golang.org/api/runtimeconfig/v1beta1

     1  // Copyright 2024 Google LLC.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Code generated file. DO NOT EDIT.
     6  
     7  // Package runtimeconfig provides access to the Cloud Runtime Configuration API.
     8  //
     9  // For product documentation, see: https://cloud.google.com/deployment-manager/runtime-configurator/
    10  //
    11  // # Library status
    12  //
    13  // These client libraries are officially supported by Google. However, this
    14  // library is considered complete and is in maintenance mode. This means
    15  // that we will address critical bugs and security issues but will not add
    16  // any new features.
    17  //
    18  // When possible, we recommend using our newer
    19  // [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go)
    20  // that are still actively being worked and iterated on.
    21  //
    22  // # Creating a client
    23  //
    24  // Usage example:
    25  //
    26  //	import "google.golang.org/api/runtimeconfig/v1beta1"
    27  //	...
    28  //	ctx := context.Background()
    29  //	runtimeconfigService, err := runtimeconfig.NewService(ctx)
    30  //
    31  // In this example, Google Application Default Credentials are used for
    32  // authentication. For information on how to create and obtain Application
    33  // Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.
    34  //
    35  // # Other authentication options
    36  //
    37  // By default, all available scopes (see "Constants") are used to authenticate.
    38  // To restrict scopes, use [google.golang.org/api/option.WithScopes]:
    39  //
    40  //	runtimeconfigService, err := runtimeconfig.NewService(ctx, option.WithScopes(runtimeconfig.CloudruntimeconfigScope))
    41  //
    42  // To use an API key for authentication (note: some APIs do not support API
    43  // keys), use [google.golang.org/api/option.WithAPIKey]:
    44  //
    45  //	runtimeconfigService, err := runtimeconfig.NewService(ctx, option.WithAPIKey("AIza..."))
    46  //
    47  // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth
    48  // flow, use [google.golang.org/api/option.WithTokenSource]:
    49  //
    50  //	config := &oauth2.Config{...}
    51  //	// ...
    52  //	token, err := config.Exchange(ctx, ...)
    53  //	runtimeconfigService, err := runtimeconfig.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
    54  //
    55  // See [google.golang.org/api/option.ClientOption] for details on options.
    56  package runtimeconfig // import "google.golang.org/api/runtimeconfig/v1beta1"
    57  
    58  import (
    59  	"bytes"
    60  	"context"
    61  	"encoding/json"
    62  	"errors"
    63  	"fmt"
    64  	"io"
    65  	"net/http"
    66  	"net/url"
    67  	"strconv"
    68  	"strings"
    69  
    70  	googleapi "google.golang.org/api/googleapi"
    71  	internal "google.golang.org/api/internal"
    72  	gensupport "google.golang.org/api/internal/gensupport"
    73  	option "google.golang.org/api/option"
    74  	internaloption "google.golang.org/api/option/internaloption"
    75  	htransport "google.golang.org/api/transport/http"
    76  )
    77  
    78  // Always reference these packages, just in case the auto-generated code
    79  // below doesn't.
    80  var _ = bytes.NewBuffer
    81  var _ = strconv.Itoa
    82  var _ = fmt.Sprintf
    83  var _ = json.NewDecoder
    84  var _ = io.Copy
    85  var _ = url.Parse
    86  var _ = gensupport.MarshalJSON
    87  var _ = googleapi.Version
    88  var _ = errors.New
    89  var _ = strings.Replace
    90  var _ = context.Canceled
    91  var _ = internaloption.WithDefaultEndpoint
    92  var _ = internal.Version
    93  
    94  const apiId = "runtimeconfig:v1beta1"
    95  const apiName = "runtimeconfig"
    96  const apiVersion = "v1beta1"
    97  const basePath = "https://runtimeconfig.googleapis.com/"
    98  const basePathTemplate = "https://runtimeconfig.UNIVERSE_DOMAIN/"
    99  const mtlsBasePath = "https://runtimeconfig.mtls.googleapis.com/"
   100  
   101  // OAuth2 scopes used by this API.
   102  const (
   103  	// See, edit, configure, and delete your Google Cloud data and see the email
   104  	// address for your Google Account.
   105  	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
   106  
   107  	// Manage your Google Cloud Platform services' runtime configuration
   108  	CloudruntimeconfigScope = "https://www.googleapis.com/auth/cloudruntimeconfig"
   109  )
   110  
   111  // NewService creates a new Service.
   112  func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
   113  	scopesOption := internaloption.WithDefaultScopes(
   114  		"https://www.googleapis.com/auth/cloud-platform",
   115  		"https://www.googleapis.com/auth/cloudruntimeconfig",
   116  	)
   117  	// NOTE: prepend, so we don't override user-specified scopes.
   118  	opts = append([]option.ClientOption{scopesOption}, opts...)
   119  	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
   120  	opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate))
   121  	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
   122  	opts = append(opts, internaloption.EnableNewAuthLibrary())
   123  	client, endpoint, err := htransport.NewClient(ctx, opts...)
   124  	if err != nil {
   125  		return nil, err
   126  	}
   127  	s, err := New(client)
   128  	if err != nil {
   129  		return nil, err
   130  	}
   131  	if endpoint != "" {
   132  		s.BasePath = endpoint
   133  	}
   134  	return s, nil
   135  }
   136  
   137  // New creates a new Service. It uses the provided http.Client for requests.
   138  //
   139  // Deprecated: please use NewService instead.
   140  // To provide a custom HTTP client, use option.WithHTTPClient.
   141  // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.
   142  func New(client *http.Client) (*Service, error) {
   143  	if client == nil {
   144  		return nil, errors.New("client is nil")
   145  	}
   146  	s := &Service{client: client, BasePath: basePath}
   147  	s.Projects = NewProjectsService(s)
   148  	return s, nil
   149  }
   150  
   151  type Service struct {
   152  	client    *http.Client
   153  	BasePath  string // API endpoint base URL
   154  	UserAgent string // optional additional User-Agent fragment
   155  
   156  	Projects *ProjectsService
   157  }
   158  
   159  func (s *Service) userAgent() string {
   160  	if s.UserAgent == "" {
   161  		return googleapi.UserAgent
   162  	}
   163  	return googleapi.UserAgent + " " + s.UserAgent
   164  }
   165  
   166  func NewProjectsService(s *Service) *ProjectsService {
   167  	rs := &ProjectsService{s: s}
   168  	rs.Configs = NewProjectsConfigsService(s)
   169  	return rs
   170  }
   171  
   172  type ProjectsService struct {
   173  	s *Service
   174  
   175  	Configs *ProjectsConfigsService
   176  }
   177  
   178  func NewProjectsConfigsService(s *Service) *ProjectsConfigsService {
   179  	rs := &ProjectsConfigsService{s: s}
   180  	rs.Operations = NewProjectsConfigsOperationsService(s)
   181  	rs.Variables = NewProjectsConfigsVariablesService(s)
   182  	rs.Waiters = NewProjectsConfigsWaitersService(s)
   183  	return rs
   184  }
   185  
   186  type ProjectsConfigsService struct {
   187  	s *Service
   188  
   189  	Operations *ProjectsConfigsOperationsService
   190  
   191  	Variables *ProjectsConfigsVariablesService
   192  
   193  	Waiters *ProjectsConfigsWaitersService
   194  }
   195  
   196  func NewProjectsConfigsOperationsService(s *Service) *ProjectsConfigsOperationsService {
   197  	rs := &ProjectsConfigsOperationsService{s: s}
   198  	return rs
   199  }
   200  
   201  type ProjectsConfigsOperationsService struct {
   202  	s *Service
   203  }
   204  
   205  func NewProjectsConfigsVariablesService(s *Service) *ProjectsConfigsVariablesService {
   206  	rs := &ProjectsConfigsVariablesService{s: s}
   207  	return rs
   208  }
   209  
   210  type ProjectsConfigsVariablesService struct {
   211  	s *Service
   212  }
   213  
   214  func NewProjectsConfigsWaitersService(s *Service) *ProjectsConfigsWaitersService {
   215  	rs := &ProjectsConfigsWaitersService{s: s}
   216  	return rs
   217  }
   218  
   219  type ProjectsConfigsWaitersService struct {
   220  	s *Service
   221  }
   222  
   223  // Binding: Associates `members`, or principals, with a `role`.
   224  type Binding struct {
   225  	// Condition: The condition that is associated with this binding. If the
   226  	// condition evaluates to `true`, then this binding applies to the current
   227  	// request. If the condition evaluates to `false`, then this binding does not
   228  	// apply to the current request. However, a different role binding might grant
   229  	// the same role to one or more of the principals in this binding. To learn
   230  	// which resources support conditions in their IAM policies, see the IAM
   231  	// documentation
   232  	// (https://cloud.google.com/iam/help/conditions/resource-policies).
   233  	Condition *Expr `json:"condition,omitempty"`
   234  	// Members: Specifies the principals requesting access for a Google Cloud
   235  	// resource. `members` can have the following values: * `allUsers`: A special
   236  	// identifier that represents anyone who is on the internet; with or without a
   237  	// Google account. * `allAuthenticatedUsers`: A special identifier that
   238  	// represents anyone who is authenticated with a Google account or a service
   239  	// account. Does not include identities that come from external identity
   240  	// providers (IdPs) through identity federation. * `user:{emailid}`: An email
   241  	// address that represents a specific Google account. For example,
   242  	// `alice@example.com` . * `serviceAccount:{emailid}`: An email address that
   243  	// represents a Google service account. For example,
   244  	// `my-other-app@appspot.gserviceaccount.com`. *
   245  	// `serviceAccount:{projectid}.svc.id.goog[{namespace}/{kubernetes-sa}]`: An
   246  	// identifier for a Kubernetes service account
   247  	// (https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts).
   248  	// For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. *
   249  	// `group:{emailid}`: An email address that represents a Google group. For
   250  	// example, `admins@example.com`. * `domain:{domain}`: The G Suite domain
   251  	// (primary) that represents all the users of that domain. For example,
   252  	// `google.com` or `example.com`. *
   253  	// `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id}/sub
   254  	// ject/{subject_attribute_value}`: A single identity in a workforce identity
   255  	// pool. *
   256  	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
   257  	// group/{group_id}`: All workforce identities in a group. *
   258  	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
   259  	// attribute.{attribute_name}/{attribute_value}`: All workforce identities with
   260  	// a specific attribute value. *
   261  	// `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id}/
   262  	// *`: All identities in a workforce identity pool. *
   263  	// `principal://iam.googleapis.com/projects/{project_number}/locations/global/wo
   264  	// rkloadIdentityPools/{pool_id}/subject/{subject_attribute_value}`: A single
   265  	// identity in a workload identity pool. *
   266  	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
   267  	// /workloadIdentityPools/{pool_id}/group/{group_id}`: A workload identity pool
   268  	// group. *
   269  	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
   270  	// /workloadIdentityPools/{pool_id}/attribute.{attribute_name}/{attribute_value}
   271  	// `: All identities in a workload identity pool with a certain attribute. *
   272  	// `principalSet://iam.googleapis.com/projects/{project_number}/locations/global
   273  	// /workloadIdentityPools/{pool_id}/*`: All identities in a workload identity
   274  	// pool. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus
   275  	// unique identifier) representing a user that has been recently deleted. For
   276  	// example, `alice@example.com?uid=123456789012345678901`. If the user is
   277  	// recovered, this value reverts to `user:{emailid}` and the recovered user
   278  	// retains the role in the binding. *
   279  	// `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus
   280  	// unique identifier) representing a service account that has been recently
   281  	// deleted. For example,
   282  	// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the
   283  	// service account is undeleted, this value reverts to
   284  	// `serviceAccount:{emailid}` and the undeleted service account retains the
   285  	// role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email
   286  	// address (plus unique identifier) representing a Google group that has been
   287  	// recently deleted. For example,
   288  	// `admins@example.com?uid=123456789012345678901`. If the group is recovered,
   289  	// this value reverts to `group:{emailid}` and the recovered group retains the
   290  	// role in the binding. *
   291  	// `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool
   292  	// _id}/subject/{subject_attribute_value}`: Deleted single identity in a
   293  	// workforce identity pool. For example,
   294  	// `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-po
   295  	// ol-id/subject/my-subject-attribute-value`.
   296  	Members []string `json:"members,omitempty"`
   297  	// Role: Role that is assigned to the list of `members`, or principals. For
   298  	// example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview
   299  	// of the IAM roles and permissions, see the IAM documentation
   300  	// (https://cloud.google.com/iam/docs/roles-overview). For a list of the
   301  	// available pre-defined roles, see here
   302  	// (https://cloud.google.com/iam/docs/understanding-roles).
   303  	Role string `json:"role,omitempty"`
   304  	// ForceSendFields is a list of field names (e.g. "Condition") to
   305  	// unconditionally include in API requests. By default, fields with empty or
   306  	// default values are omitted from API requests. See
   307  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   308  	// details.
   309  	ForceSendFields []string `json:"-"`
   310  	// NullFields is a list of field names (e.g. "Condition") to include in API
   311  	// requests with the JSON null value. By default, fields with empty values are
   312  	// omitted from API requests. See
   313  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   314  	NullFields []string `json:"-"`
   315  }
   316  
   317  func (s *Binding) MarshalJSON() ([]byte, error) {
   318  	type NoMethod Binding
   319  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   320  }
   321  
   322  // Cardinality: A Cardinality condition for the Waiter resource. A cardinality
   323  // condition is met when the number of variables under a specified path prefix
   324  // reaches a predefined number. For example, if you set a Cardinality condition
   325  // where the `path` is set to `/foo` and the number of paths is set to `2`, the
   326  // following variables would meet the condition in a RuntimeConfig resource: +
   327  // `/foo/variable1 = "value1" + `/foo/variable2 = "value2" + `/bar/variable3
   328  // = "value3" It would not satisfy the same condition with the `number` set to
   329  // `3`, however, because there is only 2 paths that start with `/foo`.
   330  // Cardinality conditions are recursive; all subtrees under the specific path
   331  // prefix are counted.
   332  type Cardinality struct {
   333  	// Number: The number variables under the `path` that must exist to meet this
   334  	// condition. Defaults to 1 if not specified.
   335  	Number int64 `json:"number,omitempty"`
   336  	// Path: The root of the variable subtree to monitor. For example, `/foo`.
   337  	Path string `json:"path,omitempty"`
   338  	// ForceSendFields is a list of field names (e.g. "Number") to unconditionally
   339  	// include in API requests. By default, fields with empty or default values are
   340  	// omitted from API requests. See
   341  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   342  	// details.
   343  	ForceSendFields []string `json:"-"`
   344  	// NullFields is a list of field names (e.g. "Number") to include in API
   345  	// requests with the JSON null value. By default, fields with empty values are
   346  	// omitted from API requests. See
   347  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   348  	NullFields []string `json:"-"`
   349  }
   350  
   351  func (s *Cardinality) MarshalJSON() ([]byte, error) {
   352  	type NoMethod Cardinality
   353  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   354  }
   355  
   356  // Empty: A generic empty message that you can re-use to avoid defining
   357  // duplicated empty messages in your APIs. A typical example is to use it as
   358  // the request or the response type of an API method. For instance: service Foo
   359  // { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }
   360  type Empty struct {
   361  	// ServerResponse contains the HTTP response code and headers from the server.
   362  	googleapi.ServerResponse `json:"-"`
   363  }
   364  
   365  // EndCondition: The condition that a Waiter resource is waiting for.
   366  type EndCondition struct {
   367  	// Cardinality: The cardinality of the `EndCondition`.
   368  	Cardinality *Cardinality `json:"cardinality,omitempty"`
   369  	// ForceSendFields is a list of field names (e.g. "Cardinality") to
   370  	// unconditionally include in API requests. By default, fields with empty or
   371  	// default values are omitted from API requests. See
   372  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   373  	// details.
   374  	ForceSendFields []string `json:"-"`
   375  	// NullFields is a list of field names (e.g. "Cardinality") to include in API
   376  	// requests with the JSON null value. By default, fields with empty values are
   377  	// omitted from API requests. See
   378  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   379  	NullFields []string `json:"-"`
   380  }
   381  
   382  func (s *EndCondition) MarshalJSON() ([]byte, error) {
   383  	type NoMethod EndCondition
   384  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   385  }
   386  
   387  // Expr: Represents a textual expression in the Common Expression Language
   388  // (CEL) syntax. CEL is a C-like expression language. The syntax and semantics
   389  // of CEL are documented at https://github.com/google/cel-spec. Example
   390  // (Comparison): title: "Summary size limit" description: "Determines if a
   391  // summary is less than 100 chars" expression: "document.summary.size() < 100"
   392  // Example (Equality): title: "Requestor is owner" description: "Determines if
   393  // requestor is the document owner" expression: "document.owner ==
   394  // request.auth.claims.email" Example (Logic): title: "Public documents"
   395  // description: "Determine whether the document should be publicly visible"
   396  // expression: "document.type != 'private' && document.type != 'internal'"
   397  // Example (Data Manipulation): title: "Notification string" description:
   398  // "Create a notification string with a timestamp." expression: "'New message
   399  // received at ' + string(document.create_time)" The exact variables and
   400  // functions that may be referenced within an expression are determined by the
   401  // service that evaluates it. See the service documentation for additional
   402  // information.
   403  type Expr struct {
   404  	// Description: Optional. Description of the expression. This is a longer text
   405  	// which describes the expression, e.g. when hovered over it in a UI.
   406  	Description string `json:"description,omitempty"`
   407  	// Expression: Textual representation of an expression in Common Expression
   408  	// Language syntax.
   409  	Expression string `json:"expression,omitempty"`
   410  	// Location: Optional. String indicating the location of the expression for
   411  	// error reporting, e.g. a file name and a position in the file.
   412  	Location string `json:"location,omitempty"`
   413  	// Title: Optional. Title for the expression, i.e. a short string describing
   414  	// its purpose. This can be used e.g. in UIs which allow to enter the
   415  	// expression.
   416  	Title string `json:"title,omitempty"`
   417  	// ForceSendFields is a list of field names (e.g. "Description") to
   418  	// unconditionally include in API requests. By default, fields with empty or
   419  	// default values are omitted from API requests. See
   420  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   421  	// details.
   422  	ForceSendFields []string `json:"-"`
   423  	// NullFields is a list of field names (e.g. "Description") to include in API
   424  	// requests with the JSON null value. By default, fields with empty values are
   425  	// omitted from API requests. See
   426  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   427  	NullFields []string `json:"-"`
   428  }
   429  
   430  func (s *Expr) MarshalJSON() ([]byte, error) {
   431  	type NoMethod Expr
   432  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   433  }
   434  
   435  // ListConfigsResponse: `ListConfigs()` returns the following response. The
   436  // order of returned objects is arbitrary; that is, it is not ordered in any
   437  // particular way.
   438  type ListConfigsResponse struct {
   439  	// Configs: A list of the configurations in the project. The order of returned
   440  	// objects is arbitrary; that is, it is not ordered in any particular way.
   441  	Configs []*RuntimeConfig `json:"configs,omitempty"`
   442  	// NextPageToken: This token allows you to get the next page of results for
   443  	// list requests. If the number of results is larger than `pageSize`, use the
   444  	// `nextPageToken` as a value for the query parameter `pageToken` in the next
   445  	// list request. Subsequent list requests will have their own `nextPageToken`
   446  	// to continue paging through the results
   447  	NextPageToken string `json:"nextPageToken,omitempty"`
   448  
   449  	// ServerResponse contains the HTTP response code and headers from the server.
   450  	googleapi.ServerResponse `json:"-"`
   451  	// ForceSendFields is a list of field names (e.g. "Configs") to unconditionally
   452  	// include in API requests. By default, fields with empty or default values are
   453  	// omitted from API requests. See
   454  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   455  	// details.
   456  	ForceSendFields []string `json:"-"`
   457  	// NullFields is a list of field names (e.g. "Configs") to include in API
   458  	// requests with the JSON null value. By default, fields with empty values are
   459  	// omitted from API requests. See
   460  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   461  	NullFields []string `json:"-"`
   462  }
   463  
   464  func (s *ListConfigsResponse) MarshalJSON() ([]byte, error) {
   465  	type NoMethod ListConfigsResponse
   466  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   467  }
   468  
   469  // ListVariablesResponse: Response for the `ListVariables()` method.
   470  type ListVariablesResponse struct {
   471  	// NextPageToken: This token allows you to get the next page of results for
   472  	// list requests. If the number of results is larger than `pageSize`, use the
   473  	// `nextPageToken` as a value for the query parameter `pageToken` in the next
   474  	// list request. Subsequent list requests will have their own `nextPageToken`
   475  	// to continue paging through the results
   476  	NextPageToken string `json:"nextPageToken,omitempty"`
   477  	// Variables: A list of variables and their values. The order of returned
   478  	// variable objects is arbitrary.
   479  	Variables []*Variable `json:"variables,omitempty"`
   480  
   481  	// ServerResponse contains the HTTP response code and headers from the server.
   482  	googleapi.ServerResponse `json:"-"`
   483  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
   484  	// unconditionally include in API requests. By default, fields with empty or
   485  	// default values are omitted from API requests. See
   486  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   487  	// details.
   488  	ForceSendFields []string `json:"-"`
   489  	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
   490  	// requests with the JSON null value. By default, fields with empty values are
   491  	// omitted from API requests. See
   492  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   493  	NullFields []string `json:"-"`
   494  }
   495  
   496  func (s *ListVariablesResponse) MarshalJSON() ([]byte, error) {
   497  	type NoMethod ListVariablesResponse
   498  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   499  }
   500  
   501  // ListWaitersResponse: Response for the `ListWaiters()` method. Order of
   502  // returned waiter objects is arbitrary.
   503  type ListWaitersResponse struct {
   504  	// NextPageToken: This token allows you to get the next page of results for
   505  	// list requests. If the number of results is larger than `pageSize`, use the
   506  	// `nextPageToken` as a value for the query parameter `pageToken` in the next
   507  	// list request. Subsequent list requests will have their own `nextPageToken`
   508  	// to continue paging through the results
   509  	NextPageToken string `json:"nextPageToken,omitempty"`
   510  	// Waiters: Found waiters in the project.
   511  	Waiters []*Waiter `json:"waiters,omitempty"`
   512  
   513  	// ServerResponse contains the HTTP response code and headers from the server.
   514  	googleapi.ServerResponse `json:"-"`
   515  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
   516  	// unconditionally include in API requests. By default, fields with empty or
   517  	// default values are omitted from API requests. See
   518  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   519  	// details.
   520  	ForceSendFields []string `json:"-"`
   521  	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
   522  	// requests with the JSON null value. By default, fields with empty values are
   523  	// omitted from API requests. See
   524  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   525  	NullFields []string `json:"-"`
   526  }
   527  
   528  func (s *ListWaitersResponse) MarshalJSON() ([]byte, error) {
   529  	type NoMethod ListWaitersResponse
   530  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   531  }
   532  
   533  // Operation: This resource represents a long-running operation that is the
   534  // result of a network API call.
   535  type Operation struct {
   536  	// Done: If the value is `false`, it means the operation is still in progress.
   537  	// If `true`, the operation is completed, and either `error` or `response` is
   538  	// available.
   539  	Done bool `json:"done,omitempty"`
   540  	// Error: The error result of the operation in case of failure or cancellation.
   541  	Error *Status `json:"error,omitempty"`
   542  	// Metadata: Service-specific metadata associated with the operation. It
   543  	// typically contains progress information and common metadata such as create
   544  	// time. Some services might not provide such metadata. Any method that returns
   545  	// a long-running operation should document the metadata type, if any.
   546  	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
   547  	// Name: The server-assigned name, which is only unique within the same service
   548  	// that originally returns it. If you use the default HTTP mapping, the `name`
   549  	// should be a resource name ending with `operations/{unique_id}`.
   550  	Name string `json:"name,omitempty"`
   551  	// Response: The normal, successful response of the operation. If the original
   552  	// method returns no data on success, such as `Delete`, the response is
   553  	// `google.protobuf.Empty`. If the original method is standard
   554  	// `Get`/`Create`/`Update`, the response should be the resource. For other
   555  	// methods, the response should have the type `XxxResponse`, where `Xxx` is the
   556  	// original method name. For example, if the original method name is
   557  	// `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
   558  	Response googleapi.RawMessage `json:"response,omitempty"`
   559  
   560  	// ServerResponse contains the HTTP response code and headers from the server.
   561  	googleapi.ServerResponse `json:"-"`
   562  	// ForceSendFields is a list of field names (e.g. "Done") to unconditionally
   563  	// include in API requests. By default, fields with empty or default values are
   564  	// omitted from API requests. See
   565  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   566  	// details.
   567  	ForceSendFields []string `json:"-"`
   568  	// NullFields is a list of field names (e.g. "Done") to include in API requests
   569  	// with the JSON null value. By default, fields with empty values are omitted
   570  	// from API requests. See
   571  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   572  	NullFields []string `json:"-"`
   573  }
   574  
   575  func (s *Operation) MarshalJSON() ([]byte, error) {
   576  	type NoMethod Operation
   577  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   578  }
   579  
   580  // Policy: An Identity and Access Management (IAM) policy, which specifies
   581  // access controls for Google Cloud resources. A `Policy` is a collection of
   582  // `bindings`. A `binding` binds one or more `members`, or principals, to a
   583  // single `role`. Principals can be user accounts, service accounts, Google
   584  // groups, and domains (such as G Suite). A `role` is a named list of
   585  // permissions; each `role` can be an IAM predefined role or a user-created
   586  // custom role. For some types of Google Cloud resources, a `binding` can also
   587  // specify a `condition`, which is a logical expression that allows access to a
   588  // resource only if the expression evaluates to `true`. A condition can add
   589  // constraints based on attributes of the request, the resource, or both. To
   590  // learn which resources support conditions in their IAM policies, see the IAM
   591  // documentation
   592  // (https://cloud.google.com/iam/help/conditions/resource-policies). **JSON
   593  // example:** ``` { "bindings": [ { "role":
   594  // "roles/resourcemanager.organizationAdmin", "members": [
   595  // "user:mike@example.com", "group:admins@example.com", "domain:google.com",
   596  // "serviceAccount:my-project-id@appspot.gserviceaccount.com" ] }, { "role":
   597  // "roles/resourcemanager.organizationViewer", "members": [
   598  // "user:eve@example.com" ], "condition": { "title": "expirable access",
   599  // "description": "Does not grant access after Sep 2020", "expression":
   600  // "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
   601  // "BwWWja0YfJA=", "version": 3 } ``` **YAML example:** ``` bindings: -
   602  // members: - user:mike@example.com - group:admins@example.com -
   603  // domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com
   604  // role: roles/resourcemanager.organizationAdmin - members: -
   605  // user:eve@example.com role: roles/resourcemanager.organizationViewer
   606  // condition: title: expirable access description: Does not grant access after
   607  // Sep 2020 expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
   608  // etag: BwWWja0YfJA= version: 3 ``` For a description of IAM and its features,
   609  // see the IAM documentation (https://cloud.google.com/iam/docs/).
   610  type Policy struct {
   611  	// Bindings: Associates a list of `members`, or principals, with a `role`.
   612  	// Optionally, may specify a `condition` that determines how and when the
   613  	// `bindings` are applied. Each of the `bindings` must contain at least one
   614  	// principal. The `bindings` in a `Policy` can refer to up to 1,500 principals;
   615  	// up to 250 of these principals can be Google groups. Each occurrence of a
   616  	// principal counts towards these limits. For example, if the `bindings` grant
   617  	// 50 different roles to `user:alice@example.com`, and not to any other
   618  	// principal, then you can add another 1,450 principals to the `bindings` in
   619  	// the `Policy`.
   620  	Bindings []*Binding `json:"bindings,omitempty"`
   621  	// Etag: `etag` is used for optimistic concurrency control as a way to help
   622  	// prevent simultaneous updates of a policy from overwriting each other. It is
   623  	// strongly suggested that systems make use of the `etag` in the
   624  	// read-modify-write cycle to perform policy updates in order to avoid race
   625  	// conditions: An `etag` is returned in the response to `getIamPolicy`, and
   626  	// systems are expected to put that etag in the request to `setIamPolicy` to
   627  	// ensure that their change will be applied to the same version of the policy.
   628  	// **Important:** If you use IAM Conditions, you must include the `etag` field
   629  	// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
   630  	// you to overwrite a version `3` policy with a version `1` policy, and all of
   631  	// the conditions in the version `3` policy are lost.
   632  	Etag string `json:"etag,omitempty"`
   633  	// Version: Specifies the format of the policy. Valid values are `0`, `1`, and
   634  	// `3`. Requests that specify an invalid value are rejected. Any operation that
   635  	// affects conditional role bindings must specify version `3`. This requirement
   636  	// applies to the following operations: * Getting a policy that includes a
   637  	// conditional role binding * Adding a conditional role binding to a policy *
   638  	// Changing a conditional role binding in a policy * Removing any role binding,
   639  	// with or without a condition, from a policy that includes conditions
   640  	// **Important:** If you use IAM Conditions, you must include the `etag` field
   641  	// whenever you call `setIamPolicy`. If you omit this field, then IAM allows
   642  	// you to overwrite a version `3` policy with a version `1` policy, and all of
   643  	// the conditions in the version `3` policy are lost. If a policy does not
   644  	// include any conditions, operations on that policy may specify any valid
   645  	// version or leave the field unset. To learn which resources support
   646  	// conditions in their IAM policies, see the IAM documentation
   647  	// (https://cloud.google.com/iam/help/conditions/resource-policies).
   648  	Version int64 `json:"version,omitempty"`
   649  
   650  	// ServerResponse contains the HTTP response code and headers from the server.
   651  	googleapi.ServerResponse `json:"-"`
   652  	// ForceSendFields is a list of field names (e.g. "Bindings") to
   653  	// unconditionally include in API requests. By default, fields with empty or
   654  	// default values are omitted from API requests. See
   655  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   656  	// details.
   657  	ForceSendFields []string `json:"-"`
   658  	// NullFields is a list of field names (e.g. "Bindings") to include in API
   659  	// requests with the JSON null value. By default, fields with empty values are
   660  	// omitted from API requests. See
   661  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   662  	NullFields []string `json:"-"`
   663  }
   664  
   665  func (s *Policy) MarshalJSON() ([]byte, error) {
   666  	type NoMethod Policy
   667  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   668  }
   669  
   670  // RuntimeConfig: A RuntimeConfig resource is the primary resource in the Cloud
   671  // RuntimeConfig service. A RuntimeConfig resource consists of metadata and a
   672  // hierarchy of variables.
   673  type RuntimeConfig struct {
   674  	// Description: An optional description of the RuntimeConfig object.
   675  	Description string `json:"description,omitempty"`
   676  	// Name: The resource name of a runtime config. The name must have the format:
   677  	// projects/[PROJECT_ID]/configs/[CONFIG_NAME] The `[PROJECT_ID]` must be a
   678  	// valid project ID, and `[CONFIG_NAME]` is an arbitrary name that matches the
   679  	// `[0-9A-Za-z](?:[_.A-Za-z0-9-]{0,62}[_.A-Za-z0-9])?` regular expression. The
   680  	// length of `[CONFIG_NAME]` must be less than 64 characters. You pick the
   681  	// RuntimeConfig resource name, but the server will validate that the name
   682  	// adheres to this format. After you create the resource, you cannot change the
   683  	// resource's name.
   684  	Name string `json:"name,omitempty"`
   685  
   686  	// ServerResponse contains the HTTP response code and headers from the server.
   687  	googleapi.ServerResponse `json:"-"`
   688  	// ForceSendFields is a list of field names (e.g. "Description") to
   689  	// unconditionally include in API requests. By default, fields with empty or
   690  	// default values are omitted from API requests. See
   691  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   692  	// details.
   693  	ForceSendFields []string `json:"-"`
   694  	// NullFields is a list of field names (e.g. "Description") to include in API
   695  	// requests with the JSON null value. By default, fields with empty values are
   696  	// omitted from API requests. See
   697  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   698  	NullFields []string `json:"-"`
   699  }
   700  
   701  func (s *RuntimeConfig) MarshalJSON() ([]byte, error) {
   702  	type NoMethod RuntimeConfig
   703  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   704  }
   705  
   706  // SetIamPolicyRequest: Request message for `SetIamPolicy` method.
   707  type SetIamPolicyRequest struct {
   708  	// Policy: REQUIRED: The complete policy to be applied to the `resource`. The
   709  	// size of the policy is limited to a few 10s of KB. An empty policy is a valid
   710  	// policy but certain Google Cloud services (such as Projects) might reject
   711  	// them.
   712  	Policy *Policy `json:"policy,omitempty"`
   713  	// ForceSendFields is a list of field names (e.g. "Policy") to unconditionally
   714  	// include in API requests. By default, fields with empty or default values are
   715  	// omitted from API requests. See
   716  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   717  	// details.
   718  	ForceSendFields []string `json:"-"`
   719  	// NullFields is a list of field names (e.g. "Policy") to include in API
   720  	// requests with the JSON null value. By default, fields with empty values are
   721  	// omitted from API requests. See
   722  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   723  	NullFields []string `json:"-"`
   724  }
   725  
   726  func (s *SetIamPolicyRequest) MarshalJSON() ([]byte, error) {
   727  	type NoMethod SetIamPolicyRequest
   728  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   729  }
   730  
   731  // Status: The `Status` type defines a logical error model that is suitable for
   732  // different programming environments, including REST APIs and RPC APIs. It is
   733  // used by gRPC (https://github.com/grpc). Each `Status` message contains three
   734  // pieces of data: error code, error message, and error details. You can find
   735  // out more about this error model and how to work with it in the API Design
   736  // Guide (https://cloud.google.com/apis/design/errors).
   737  type Status struct {
   738  	// Code: The status code, which should be an enum value of google.rpc.Code.
   739  	Code int64 `json:"code,omitempty"`
   740  	// Details: A list of messages that carry the error details. There is a common
   741  	// set of message types for APIs to use.
   742  	Details []googleapi.RawMessage `json:"details,omitempty"`
   743  	// Message: A developer-facing error message, which should be in English. Any
   744  	// user-facing error message should be localized and sent in the
   745  	// google.rpc.Status.details field, or localized by the client.
   746  	Message string `json:"message,omitempty"`
   747  	// ForceSendFields is a list of field names (e.g. "Code") to unconditionally
   748  	// include in API requests. By default, fields with empty or default values are
   749  	// omitted from API requests. See
   750  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   751  	// details.
   752  	ForceSendFields []string `json:"-"`
   753  	// NullFields is a list of field names (e.g. "Code") to include in API requests
   754  	// with the JSON null value. By default, fields with empty values are omitted
   755  	// from API requests. See
   756  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   757  	NullFields []string `json:"-"`
   758  }
   759  
   760  func (s *Status) MarshalJSON() ([]byte, error) {
   761  	type NoMethod Status
   762  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   763  }
   764  
   765  // TestIamPermissionsRequest: Request message for `TestIamPermissions` method.
   766  type TestIamPermissionsRequest struct {
   767  	// Permissions: The set of permissions to check for the `resource`. Permissions
   768  	// with wildcards (such as `*` or `storage.*`) are not allowed. For more
   769  	// information see IAM Overview
   770  	// (https://cloud.google.com/iam/docs/overview#permissions).
   771  	Permissions []string `json:"permissions,omitempty"`
   772  	// ForceSendFields is a list of field names (e.g. "Permissions") to
   773  	// unconditionally include in API requests. By default, fields with empty or
   774  	// default values are omitted from API requests. See
   775  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   776  	// details.
   777  	ForceSendFields []string `json:"-"`
   778  	// NullFields is a list of field names (e.g. "Permissions") to include in API
   779  	// requests with the JSON null value. By default, fields with empty values are
   780  	// omitted from API requests. See
   781  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   782  	NullFields []string `json:"-"`
   783  }
   784  
   785  func (s *TestIamPermissionsRequest) MarshalJSON() ([]byte, error) {
   786  	type NoMethod TestIamPermissionsRequest
   787  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   788  }
   789  
   790  // TestIamPermissionsResponse: Response message for `TestIamPermissions`
   791  // method.
   792  type TestIamPermissionsResponse struct {
   793  	// Permissions: A subset of `TestPermissionsRequest.permissions` that the
   794  	// caller is allowed.
   795  	Permissions []string `json:"permissions,omitempty"`
   796  
   797  	// ServerResponse contains the HTTP response code and headers from the server.
   798  	googleapi.ServerResponse `json:"-"`
   799  	// ForceSendFields is a list of field names (e.g. "Permissions") to
   800  	// unconditionally include in API requests. By default, fields with empty or
   801  	// default values are omitted from API requests. See
   802  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   803  	// details.
   804  	ForceSendFields []string `json:"-"`
   805  	// NullFields is a list of field names (e.g. "Permissions") to include in API
   806  	// requests with the JSON null value. By default, fields with empty values are
   807  	// omitted from API requests. See
   808  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   809  	NullFields []string `json:"-"`
   810  }
   811  
   812  func (s *TestIamPermissionsResponse) MarshalJSON() ([]byte, error) {
   813  	type NoMethod TestIamPermissionsResponse
   814  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   815  }
   816  
   817  // Variable: Describes a single variable within a RuntimeConfig resource. The
   818  // name denotes the hierarchical variable name. For example,
   819  // `ports/serving_port` is a valid variable name. The variable value is an
   820  // opaque string and only leaf variables can have values (that is, variables
   821  // that do not have any child variables).
   822  type Variable struct {
   823  	// Name: The name of the variable resource, in the format:
   824  	// projects/[PROJECT_ID]/configs/[CONFIG_NAME]/variables/[VARIABLE_NAME] The
   825  	// `[PROJECT_ID]` must be a valid project ID, `[CONFIG_NAME]` must be a valid
   826  	// RuntimeConfig resource and `[VARIABLE_NAME]` follows Unix file system file
   827  	// path naming. The `[VARIABLE_NAME]` can contain ASCII letters, numbers,
   828  	// slashes and dashes. Slashes are used as path element separators and are not
   829  	// part of the `[VARIABLE_NAME]` itself, so `[VARIABLE_NAME]` must contain at
   830  	// least one non-slash character. Multiple slashes are coalesced into single
   831  	// slash character. Each path segment should match 0-9A-Za-z
   832  	// (?:[_.A-Za-z0-9-]{0,62}[_.A-Za-z0-9])? regular expression. The length of a
   833  	// `[VARIABLE_NAME]` must be less than 256 characters. Once you create a
   834  	// variable, you cannot change the variable name.
   835  	Name string `json:"name,omitempty"`
   836  	// State: Output only. The current state of the variable. The variable state
   837  	// indicates the outcome of the `variables().watch` call and is visible through
   838  	// the `get` and `list` calls.
   839  	//
   840  	// Possible values:
   841  	//   "VARIABLE_STATE_UNSPECIFIED" - Default variable state.
   842  	//   "UPDATED" - The variable was updated, while `variables().watch` was
   843  	// executing.
   844  	//   "DELETED" - The variable was deleted, while `variables().watch` was
   845  	// executing.
   846  	State string `json:"state,omitempty"`
   847  	// Text: The string value of the variable. The length of the value must be less
   848  	// than 4096 bytes. Empty values are also accepted. For example, `text: "my
   849  	// text value". The string must be valid UTF-8.
   850  	Text string `json:"text,omitempty"`
   851  	// UpdateTime: Output only. The time of the last variable update. Timestamp
   852  	// will be UTC timestamp.
   853  	UpdateTime string `json:"updateTime,omitempty"`
   854  	// Value: The binary value of the variable. The length of the value must be
   855  	// less than 4096 bytes. Empty values are also accepted. The value must be
   856  	// base64 encoded, and must comply with IETF RFC4648
   857  	// (https://www.ietf.org/rfc/rfc4648.txt). Only one of `value` or `text` can be
   858  	// set.
   859  	Value string `json:"value,omitempty"`
   860  
   861  	// ServerResponse contains the HTTP response code and headers from the server.
   862  	googleapi.ServerResponse `json:"-"`
   863  	// ForceSendFields is a list of field names (e.g. "Name") to unconditionally
   864  	// include in API requests. By default, fields with empty or default values are
   865  	// omitted from API requests. See
   866  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   867  	// details.
   868  	ForceSendFields []string `json:"-"`
   869  	// NullFields is a list of field names (e.g. "Name") to include in API requests
   870  	// with the JSON null value. By default, fields with empty values are omitted
   871  	// from API requests. See
   872  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   873  	NullFields []string `json:"-"`
   874  }
   875  
   876  func (s *Variable) MarshalJSON() ([]byte, error) {
   877  	type NoMethod Variable
   878  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   879  }
   880  
   881  // Waiter: A Waiter resource waits for some end condition within a
   882  // RuntimeConfig resource to be met before it returns. For example, assume you
   883  // have a distributed system where each node writes to a Variable resource
   884  // indicating the node's readiness as part of the startup process. You then
   885  // configure a Waiter resource with the success condition set to wait until
   886  // some number of nodes have checked in. Afterwards, your application runs some
   887  // arbitrary code after the condition has been met and the waiter returns
   888  // successfully. Once created, a Waiter resource is immutable. To learn more
   889  // about using waiters, read the Creating a Waiter
   890  // (/deployment-manager/runtime-configurator/creating-a-waiter) documentation.
   891  type Waiter struct {
   892  	// CreateTime: Output only. The instant at which this Waiter resource was
   893  	// created. Adding the value of `timeout` to this instant yields the timeout
   894  	// deadline for the waiter.
   895  	CreateTime string `json:"createTime,omitempty"`
   896  	// Done: Output only. If the value is `false`, it means the waiter is still
   897  	// waiting for one of its conditions to be met. If true, the waiter has
   898  	// finished. If the waiter finished due to a timeout or failure, `error` will
   899  	// be set.
   900  	Done bool `json:"done,omitempty"`
   901  	// Error: Output only. If the waiter ended due to a failure or timeout, this
   902  	// value will be set.
   903  	Error *Status `json:"error,omitempty"`
   904  	// Failure: [Optional] The failure condition of this waiter. If this condition
   905  	// is met, `done` will be set to `true` and the `error` code will be set to
   906  	// `ABORTED`. The failure condition takes precedence over the success
   907  	// condition. If both conditions are met, a failure will be indicated. This
   908  	// value is optional; if no failure condition is set, the only failure scenario
   909  	// will be a timeout.
   910  	Failure *EndCondition `json:"failure,omitempty"`
   911  	// Name: The name of the Waiter resource, in the format:
   912  	// projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME] The
   913  	// `[PROJECT_ID]` must be a valid Google Cloud project ID, the `[CONFIG_NAME]`
   914  	// must be a valid RuntimeConfig resource, the `[WAITER_NAME]` must match RFC
   915  	// 1035 segment specification, and the length of `[WAITER_NAME]` must be less
   916  	// than 64 bytes. After you create a Waiter resource, you cannot change the
   917  	// resource name.
   918  	Name string `json:"name,omitempty"`
   919  	// Success: [Required] The success condition. If this condition is met, `done`
   920  	// will be set to `true` and the `error` value will remain unset. The failure
   921  	// condition takes precedence over the success condition. If both conditions
   922  	// are met, a failure will be indicated.
   923  	Success *EndCondition `json:"success,omitempty"`
   924  	// Timeout: [Required] Specifies the timeout of the waiter in seconds,
   925  	// beginning from the instant that `waiters().create` method is called. If this
   926  	// time elapses before the success or failure conditions are met, the waiter
   927  	// fails and sets the `error` code to `DEADLINE_EXCEEDED`.
   928  	Timeout string `json:"timeout,omitempty"`
   929  
   930  	// ServerResponse contains the HTTP response code and headers from the server.
   931  	googleapi.ServerResponse `json:"-"`
   932  	// ForceSendFields is a list of field names (e.g. "CreateTime") to
   933  	// unconditionally include in API requests. By default, fields with empty or
   934  	// default values are omitted from API requests. See
   935  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   936  	// details.
   937  	ForceSendFields []string `json:"-"`
   938  	// NullFields is a list of field names (e.g. "CreateTime") to include in API
   939  	// requests with the JSON null value. By default, fields with empty values are
   940  	// omitted from API requests. See
   941  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   942  	NullFields []string `json:"-"`
   943  }
   944  
   945  func (s *Waiter) MarshalJSON() ([]byte, error) {
   946  	type NoMethod Waiter
   947  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   948  }
   949  
   950  // WatchVariableRequest: Request for the `WatchVariable()` method.
   951  type WatchVariableRequest struct {
   952  	// NewerThan: If specified, checks the current timestamp of the variable and if
   953  	// the current timestamp is newer than `newerThan` timestamp, the method
   954  	// returns immediately. If not specified or the variable has an older
   955  	// timestamp, the watcher waits for a the value to change before returning.
   956  	NewerThan string `json:"newerThan,omitempty"`
   957  	// ForceSendFields is a list of field names (e.g. "NewerThan") to
   958  	// unconditionally include in API requests. By default, fields with empty or
   959  	// default values are omitted from API requests. See
   960  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   961  	// details.
   962  	ForceSendFields []string `json:"-"`
   963  	// NullFields is a list of field names (e.g. "NewerThan") to include in API
   964  	// requests with the JSON null value. By default, fields with empty values are
   965  	// omitted from API requests. See
   966  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   967  	NullFields []string `json:"-"`
   968  }
   969  
   970  func (s *WatchVariableRequest) MarshalJSON() ([]byte, error) {
   971  	type NoMethod WatchVariableRequest
   972  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   973  }
   974  
   975  type ProjectsConfigsCreateCall struct {
   976  	s             *Service
   977  	parent        string
   978  	runtimeconfig *RuntimeConfig
   979  	urlParams_    gensupport.URLParams
   980  	ctx_          context.Context
   981  	header_       http.Header
   982  }
   983  
   984  // Create: Creates a new RuntimeConfig resource. The configuration name must be
   985  // unique within project.
   986  //
   987  //   - parent: The project ID
   988  //     (https://support.google.com/cloud/answer/6158840?hl=en&ref_topic=6158848)
   989  //     for this request, in the format `projects/[PROJECT_ID]`.
   990  func (r *ProjectsConfigsService) Create(parent string, runtimeconfig *RuntimeConfig) *ProjectsConfigsCreateCall {
   991  	c := &ProjectsConfigsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
   992  	c.parent = parent
   993  	c.runtimeconfig = runtimeconfig
   994  	return c
   995  }
   996  
   997  // RequestId sets the optional parameter "requestId": An optional but
   998  // recommended unique `request_id`. If the server receives two `create()`
   999  // requests with the same `request_id`, then the second request will be ignored
  1000  // and the first resource created and stored in the backend is returned. Empty
  1001  // `request_id` fields are ignored. It is responsibility of the client to
  1002  // ensure uniqueness of the `request_id` strings. `request_id` strings are
  1003  // limited to 64 characters.
  1004  func (c *ProjectsConfigsCreateCall) RequestId(requestId string) *ProjectsConfigsCreateCall {
  1005  	c.urlParams_.Set("requestId", requestId)
  1006  	return c
  1007  }
  1008  
  1009  // Fields allows partial responses to be retrieved. See
  1010  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1011  // details.
  1012  func (c *ProjectsConfigsCreateCall) Fields(s ...googleapi.Field) *ProjectsConfigsCreateCall {
  1013  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1014  	return c
  1015  }
  1016  
  1017  // Context sets the context to be used in this call's Do method.
  1018  func (c *ProjectsConfigsCreateCall) Context(ctx context.Context) *ProjectsConfigsCreateCall {
  1019  	c.ctx_ = ctx
  1020  	return c
  1021  }
  1022  
  1023  // Header returns a http.Header that can be modified by the caller to add
  1024  // headers to the request.
  1025  func (c *ProjectsConfigsCreateCall) Header() http.Header {
  1026  	if c.header_ == nil {
  1027  		c.header_ = make(http.Header)
  1028  	}
  1029  	return c.header_
  1030  }
  1031  
  1032  func (c *ProjectsConfigsCreateCall) doRequest(alt string) (*http.Response, error) {
  1033  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  1034  	var body io.Reader = nil
  1035  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.runtimeconfig)
  1036  	if err != nil {
  1037  		return nil, err
  1038  	}
  1039  	c.urlParams_.Set("alt", alt)
  1040  	c.urlParams_.Set("prettyPrint", "false")
  1041  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/configs")
  1042  	urls += "?" + c.urlParams_.Encode()
  1043  	req, err := http.NewRequest("POST", urls, body)
  1044  	if err != nil {
  1045  		return nil, err
  1046  	}
  1047  	req.Header = reqHeaders
  1048  	googleapi.Expand(req.URL, map[string]string{
  1049  		"parent": c.parent,
  1050  	})
  1051  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1052  }
  1053  
  1054  // Do executes the "runtimeconfig.projects.configs.create" call.
  1055  // Any non-2xx status code is an error. Response headers are in either
  1056  // *RuntimeConfig.ServerResponse.Header or (if a response was returned at all)
  1057  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1058  // whether the returned error was because http.StatusNotModified was returned.
  1059  func (c *ProjectsConfigsCreateCall) Do(opts ...googleapi.CallOption) (*RuntimeConfig, error) {
  1060  	gensupport.SetOptions(c.urlParams_, opts...)
  1061  	res, err := c.doRequest("json")
  1062  	if res != nil && res.StatusCode == http.StatusNotModified {
  1063  		if res.Body != nil {
  1064  			res.Body.Close()
  1065  		}
  1066  		return nil, gensupport.WrapError(&googleapi.Error{
  1067  			Code:   res.StatusCode,
  1068  			Header: res.Header,
  1069  		})
  1070  	}
  1071  	if err != nil {
  1072  		return nil, err
  1073  	}
  1074  	defer googleapi.CloseBody(res)
  1075  	if err := googleapi.CheckResponse(res); err != nil {
  1076  		return nil, gensupport.WrapError(err)
  1077  	}
  1078  	ret := &RuntimeConfig{
  1079  		ServerResponse: googleapi.ServerResponse{
  1080  			Header:         res.Header,
  1081  			HTTPStatusCode: res.StatusCode,
  1082  		},
  1083  	}
  1084  	target := &ret
  1085  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1086  		return nil, err
  1087  	}
  1088  	return ret, nil
  1089  }
  1090  
  1091  type ProjectsConfigsDeleteCall struct {
  1092  	s          *Service
  1093  	name       string
  1094  	urlParams_ gensupport.URLParams
  1095  	ctx_       context.Context
  1096  	header_    http.Header
  1097  }
  1098  
  1099  // Delete: Deletes a RuntimeConfig resource.
  1100  //
  1101  //   - name: The RuntimeConfig resource to delete, in the format:
  1102  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  1103  func (r *ProjectsConfigsService) Delete(name string) *ProjectsConfigsDeleteCall {
  1104  	c := &ProjectsConfigsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1105  	c.name = name
  1106  	return c
  1107  }
  1108  
  1109  // Fields allows partial responses to be retrieved. See
  1110  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1111  // details.
  1112  func (c *ProjectsConfigsDeleteCall) Fields(s ...googleapi.Field) *ProjectsConfigsDeleteCall {
  1113  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1114  	return c
  1115  }
  1116  
  1117  // Context sets the context to be used in this call's Do method.
  1118  func (c *ProjectsConfigsDeleteCall) Context(ctx context.Context) *ProjectsConfigsDeleteCall {
  1119  	c.ctx_ = ctx
  1120  	return c
  1121  }
  1122  
  1123  // Header returns a http.Header that can be modified by the caller to add
  1124  // headers to the request.
  1125  func (c *ProjectsConfigsDeleteCall) Header() http.Header {
  1126  	if c.header_ == nil {
  1127  		c.header_ = make(http.Header)
  1128  	}
  1129  	return c.header_
  1130  }
  1131  
  1132  func (c *ProjectsConfigsDeleteCall) doRequest(alt string) (*http.Response, error) {
  1133  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1134  	var body io.Reader = nil
  1135  	c.urlParams_.Set("alt", alt)
  1136  	c.urlParams_.Set("prettyPrint", "false")
  1137  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  1138  	urls += "?" + c.urlParams_.Encode()
  1139  	req, err := http.NewRequest("DELETE", urls, body)
  1140  	if err != nil {
  1141  		return nil, err
  1142  	}
  1143  	req.Header = reqHeaders
  1144  	googleapi.Expand(req.URL, map[string]string{
  1145  		"name": c.name,
  1146  	})
  1147  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1148  }
  1149  
  1150  // Do executes the "runtimeconfig.projects.configs.delete" call.
  1151  // Any non-2xx status code is an error. Response headers are in either
  1152  // *Empty.ServerResponse.Header or (if a response was returned at all) in
  1153  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1154  // whether the returned error was because http.StatusNotModified was returned.
  1155  func (c *ProjectsConfigsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  1156  	gensupport.SetOptions(c.urlParams_, opts...)
  1157  	res, err := c.doRequest("json")
  1158  	if res != nil && res.StatusCode == http.StatusNotModified {
  1159  		if res.Body != nil {
  1160  			res.Body.Close()
  1161  		}
  1162  		return nil, gensupport.WrapError(&googleapi.Error{
  1163  			Code:   res.StatusCode,
  1164  			Header: res.Header,
  1165  		})
  1166  	}
  1167  	if err != nil {
  1168  		return nil, err
  1169  	}
  1170  	defer googleapi.CloseBody(res)
  1171  	if err := googleapi.CheckResponse(res); err != nil {
  1172  		return nil, gensupport.WrapError(err)
  1173  	}
  1174  	ret := &Empty{
  1175  		ServerResponse: googleapi.ServerResponse{
  1176  			Header:         res.Header,
  1177  			HTTPStatusCode: res.StatusCode,
  1178  		},
  1179  	}
  1180  	target := &ret
  1181  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1182  		return nil, err
  1183  	}
  1184  	return ret, nil
  1185  }
  1186  
  1187  type ProjectsConfigsGetCall struct {
  1188  	s            *Service
  1189  	name         string
  1190  	urlParams_   gensupport.URLParams
  1191  	ifNoneMatch_ string
  1192  	ctx_         context.Context
  1193  	header_      http.Header
  1194  }
  1195  
  1196  // Get: Gets information about a RuntimeConfig resource.
  1197  //
  1198  //   - name: The name of the RuntimeConfig resource to retrieve, in the format:
  1199  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  1200  func (r *ProjectsConfigsService) Get(name string) *ProjectsConfigsGetCall {
  1201  	c := &ProjectsConfigsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1202  	c.name = name
  1203  	return c
  1204  }
  1205  
  1206  // Fields allows partial responses to be retrieved. See
  1207  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1208  // details.
  1209  func (c *ProjectsConfigsGetCall) Fields(s ...googleapi.Field) *ProjectsConfigsGetCall {
  1210  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1211  	return c
  1212  }
  1213  
  1214  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  1215  // object's ETag matches the given value. This is useful for getting updates
  1216  // only after the object has changed since the last request.
  1217  func (c *ProjectsConfigsGetCall) IfNoneMatch(entityTag string) *ProjectsConfigsGetCall {
  1218  	c.ifNoneMatch_ = entityTag
  1219  	return c
  1220  }
  1221  
  1222  // Context sets the context to be used in this call's Do method.
  1223  func (c *ProjectsConfigsGetCall) Context(ctx context.Context) *ProjectsConfigsGetCall {
  1224  	c.ctx_ = ctx
  1225  	return c
  1226  }
  1227  
  1228  // Header returns a http.Header that can be modified by the caller to add
  1229  // headers to the request.
  1230  func (c *ProjectsConfigsGetCall) Header() http.Header {
  1231  	if c.header_ == nil {
  1232  		c.header_ = make(http.Header)
  1233  	}
  1234  	return c.header_
  1235  }
  1236  
  1237  func (c *ProjectsConfigsGetCall) doRequest(alt string) (*http.Response, error) {
  1238  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1239  	if c.ifNoneMatch_ != "" {
  1240  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1241  	}
  1242  	var body io.Reader = nil
  1243  	c.urlParams_.Set("alt", alt)
  1244  	c.urlParams_.Set("prettyPrint", "false")
  1245  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  1246  	urls += "?" + c.urlParams_.Encode()
  1247  	req, err := http.NewRequest("GET", urls, body)
  1248  	if err != nil {
  1249  		return nil, err
  1250  	}
  1251  	req.Header = reqHeaders
  1252  	googleapi.Expand(req.URL, map[string]string{
  1253  		"name": c.name,
  1254  	})
  1255  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1256  }
  1257  
  1258  // Do executes the "runtimeconfig.projects.configs.get" call.
  1259  // Any non-2xx status code is an error. Response headers are in either
  1260  // *RuntimeConfig.ServerResponse.Header or (if a response was returned at all)
  1261  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1262  // whether the returned error was because http.StatusNotModified was returned.
  1263  func (c *ProjectsConfigsGetCall) Do(opts ...googleapi.CallOption) (*RuntimeConfig, error) {
  1264  	gensupport.SetOptions(c.urlParams_, opts...)
  1265  	res, err := c.doRequest("json")
  1266  	if res != nil && res.StatusCode == http.StatusNotModified {
  1267  		if res.Body != nil {
  1268  			res.Body.Close()
  1269  		}
  1270  		return nil, gensupport.WrapError(&googleapi.Error{
  1271  			Code:   res.StatusCode,
  1272  			Header: res.Header,
  1273  		})
  1274  	}
  1275  	if err != nil {
  1276  		return nil, err
  1277  	}
  1278  	defer googleapi.CloseBody(res)
  1279  	if err := googleapi.CheckResponse(res); err != nil {
  1280  		return nil, gensupport.WrapError(err)
  1281  	}
  1282  	ret := &RuntimeConfig{
  1283  		ServerResponse: googleapi.ServerResponse{
  1284  			Header:         res.Header,
  1285  			HTTPStatusCode: res.StatusCode,
  1286  		},
  1287  	}
  1288  	target := &ret
  1289  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1290  		return nil, err
  1291  	}
  1292  	return ret, nil
  1293  }
  1294  
  1295  type ProjectsConfigsGetIamPolicyCall struct {
  1296  	s            *Service
  1297  	resource     string
  1298  	urlParams_   gensupport.URLParams
  1299  	ifNoneMatch_ string
  1300  	ctx_         context.Context
  1301  	header_      http.Header
  1302  }
  1303  
  1304  // GetIamPolicy: Gets the access control policy for a resource. Returns an
  1305  // empty policy if the resource exists and does not have a policy set.
  1306  //
  1307  //   - resource: REQUIRED: The resource for which the policy is being requested.
  1308  //     See Resource names (https://cloud.google.com/apis/design/resource_names)
  1309  //     for the appropriate value for this field.
  1310  func (r *ProjectsConfigsService) GetIamPolicy(resource string) *ProjectsConfigsGetIamPolicyCall {
  1311  	c := &ProjectsConfigsGetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1312  	c.resource = resource
  1313  	return c
  1314  }
  1315  
  1316  // OptionsRequestedPolicyVersion sets the optional parameter
  1317  // "options.requestedPolicyVersion": The maximum policy version that will be
  1318  // used to format the policy. Valid values are 0, 1, and 3. Requests specifying
  1319  // an invalid value will be rejected. Requests for policies with any
  1320  // conditional role bindings must specify version 3. Policies with no
  1321  // conditional role bindings may specify any valid value or leave the field
  1322  // unset. The policy in the response might use the policy version that you
  1323  // specified, or it might use a lower policy version. For example, if you
  1324  // specify version 3, but the policy has no conditional role bindings, the
  1325  // response uses version 1. To learn which resources support conditions in
  1326  // their IAM policies, see the IAM documentation
  1327  // (https://cloud.google.com/iam/help/conditions/resource-policies).
  1328  func (c *ProjectsConfigsGetIamPolicyCall) OptionsRequestedPolicyVersion(optionsRequestedPolicyVersion int64) *ProjectsConfigsGetIamPolicyCall {
  1329  	c.urlParams_.Set("options.requestedPolicyVersion", fmt.Sprint(optionsRequestedPolicyVersion))
  1330  	return c
  1331  }
  1332  
  1333  // Fields allows partial responses to be retrieved. See
  1334  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1335  // details.
  1336  func (c *ProjectsConfigsGetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsConfigsGetIamPolicyCall {
  1337  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1338  	return c
  1339  }
  1340  
  1341  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  1342  // object's ETag matches the given value. This is useful for getting updates
  1343  // only after the object has changed since the last request.
  1344  func (c *ProjectsConfigsGetIamPolicyCall) IfNoneMatch(entityTag string) *ProjectsConfigsGetIamPolicyCall {
  1345  	c.ifNoneMatch_ = entityTag
  1346  	return c
  1347  }
  1348  
  1349  // Context sets the context to be used in this call's Do method.
  1350  func (c *ProjectsConfigsGetIamPolicyCall) Context(ctx context.Context) *ProjectsConfigsGetIamPolicyCall {
  1351  	c.ctx_ = ctx
  1352  	return c
  1353  }
  1354  
  1355  // Header returns a http.Header that can be modified by the caller to add
  1356  // headers to the request.
  1357  func (c *ProjectsConfigsGetIamPolicyCall) Header() http.Header {
  1358  	if c.header_ == nil {
  1359  		c.header_ = make(http.Header)
  1360  	}
  1361  	return c.header_
  1362  }
  1363  
  1364  func (c *ProjectsConfigsGetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
  1365  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1366  	if c.ifNoneMatch_ != "" {
  1367  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1368  	}
  1369  	var body io.Reader = nil
  1370  	c.urlParams_.Set("alt", alt)
  1371  	c.urlParams_.Set("prettyPrint", "false")
  1372  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:getIamPolicy")
  1373  	urls += "?" + c.urlParams_.Encode()
  1374  	req, err := http.NewRequest("GET", urls, body)
  1375  	if err != nil {
  1376  		return nil, err
  1377  	}
  1378  	req.Header = reqHeaders
  1379  	googleapi.Expand(req.URL, map[string]string{
  1380  		"resource": c.resource,
  1381  	})
  1382  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1383  }
  1384  
  1385  // Do executes the "runtimeconfig.projects.configs.getIamPolicy" call.
  1386  // Any non-2xx status code is an error. Response headers are in either
  1387  // *Policy.ServerResponse.Header or (if a response was returned at all) in
  1388  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1389  // whether the returned error was because http.StatusNotModified was returned.
  1390  func (c *ProjectsConfigsGetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
  1391  	gensupport.SetOptions(c.urlParams_, opts...)
  1392  	res, err := c.doRequest("json")
  1393  	if res != nil && res.StatusCode == http.StatusNotModified {
  1394  		if res.Body != nil {
  1395  			res.Body.Close()
  1396  		}
  1397  		return nil, gensupport.WrapError(&googleapi.Error{
  1398  			Code:   res.StatusCode,
  1399  			Header: res.Header,
  1400  		})
  1401  	}
  1402  	if err != nil {
  1403  		return nil, err
  1404  	}
  1405  	defer googleapi.CloseBody(res)
  1406  	if err := googleapi.CheckResponse(res); err != nil {
  1407  		return nil, gensupport.WrapError(err)
  1408  	}
  1409  	ret := &Policy{
  1410  		ServerResponse: googleapi.ServerResponse{
  1411  			Header:         res.Header,
  1412  			HTTPStatusCode: res.StatusCode,
  1413  		},
  1414  	}
  1415  	target := &ret
  1416  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1417  		return nil, err
  1418  	}
  1419  	return ret, nil
  1420  }
  1421  
  1422  type ProjectsConfigsListCall struct {
  1423  	s            *Service
  1424  	parent       string
  1425  	urlParams_   gensupport.URLParams
  1426  	ifNoneMatch_ string
  1427  	ctx_         context.Context
  1428  	header_      http.Header
  1429  }
  1430  
  1431  // List: Lists all the RuntimeConfig resources within project.
  1432  //
  1433  //   - parent: The project ID
  1434  //     (https://support.google.com/cloud/answer/6158840?hl=en&ref_topic=6158848)
  1435  //     for this request, in the format `projects/[PROJECT_ID]`.
  1436  func (r *ProjectsConfigsService) List(parent string) *ProjectsConfigsListCall {
  1437  	c := &ProjectsConfigsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1438  	c.parent = parent
  1439  	return c
  1440  }
  1441  
  1442  // PageSize sets the optional parameter "pageSize": Specifies the number of
  1443  // results to return per page. If there are fewer elements than the specified
  1444  // number, returns all elements.
  1445  func (c *ProjectsConfigsListCall) PageSize(pageSize int64) *ProjectsConfigsListCall {
  1446  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  1447  	return c
  1448  }
  1449  
  1450  // PageToken sets the optional parameter "pageToken": Specifies a page token to
  1451  // use. Set `pageToken` to a `nextPageToken` returned by a previous list
  1452  // request to get the next page of results.
  1453  func (c *ProjectsConfigsListCall) PageToken(pageToken string) *ProjectsConfigsListCall {
  1454  	c.urlParams_.Set("pageToken", pageToken)
  1455  	return c
  1456  }
  1457  
  1458  // Fields allows partial responses to be retrieved. See
  1459  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1460  // details.
  1461  func (c *ProjectsConfigsListCall) Fields(s ...googleapi.Field) *ProjectsConfigsListCall {
  1462  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1463  	return c
  1464  }
  1465  
  1466  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  1467  // object's ETag matches the given value. This is useful for getting updates
  1468  // only after the object has changed since the last request.
  1469  func (c *ProjectsConfigsListCall) IfNoneMatch(entityTag string) *ProjectsConfigsListCall {
  1470  	c.ifNoneMatch_ = entityTag
  1471  	return c
  1472  }
  1473  
  1474  // Context sets the context to be used in this call's Do method.
  1475  func (c *ProjectsConfigsListCall) Context(ctx context.Context) *ProjectsConfigsListCall {
  1476  	c.ctx_ = ctx
  1477  	return c
  1478  }
  1479  
  1480  // Header returns a http.Header that can be modified by the caller to add
  1481  // headers to the request.
  1482  func (c *ProjectsConfigsListCall) Header() http.Header {
  1483  	if c.header_ == nil {
  1484  		c.header_ = make(http.Header)
  1485  	}
  1486  	return c.header_
  1487  }
  1488  
  1489  func (c *ProjectsConfigsListCall) doRequest(alt string) (*http.Response, error) {
  1490  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1491  	if c.ifNoneMatch_ != "" {
  1492  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1493  	}
  1494  	var body io.Reader = nil
  1495  	c.urlParams_.Set("alt", alt)
  1496  	c.urlParams_.Set("prettyPrint", "false")
  1497  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/configs")
  1498  	urls += "?" + c.urlParams_.Encode()
  1499  	req, err := http.NewRequest("GET", urls, body)
  1500  	if err != nil {
  1501  		return nil, err
  1502  	}
  1503  	req.Header = reqHeaders
  1504  	googleapi.Expand(req.URL, map[string]string{
  1505  		"parent": c.parent,
  1506  	})
  1507  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1508  }
  1509  
  1510  // Do executes the "runtimeconfig.projects.configs.list" call.
  1511  // Any non-2xx status code is an error. Response headers are in either
  1512  // *ListConfigsResponse.ServerResponse.Header or (if a response was returned at
  1513  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  1514  // check whether the returned error was because http.StatusNotModified was
  1515  // returned.
  1516  func (c *ProjectsConfigsListCall) Do(opts ...googleapi.CallOption) (*ListConfigsResponse, error) {
  1517  	gensupport.SetOptions(c.urlParams_, opts...)
  1518  	res, err := c.doRequest("json")
  1519  	if res != nil && res.StatusCode == http.StatusNotModified {
  1520  		if res.Body != nil {
  1521  			res.Body.Close()
  1522  		}
  1523  		return nil, gensupport.WrapError(&googleapi.Error{
  1524  			Code:   res.StatusCode,
  1525  			Header: res.Header,
  1526  		})
  1527  	}
  1528  	if err != nil {
  1529  		return nil, err
  1530  	}
  1531  	defer googleapi.CloseBody(res)
  1532  	if err := googleapi.CheckResponse(res); err != nil {
  1533  		return nil, gensupport.WrapError(err)
  1534  	}
  1535  	ret := &ListConfigsResponse{
  1536  		ServerResponse: googleapi.ServerResponse{
  1537  			Header:         res.Header,
  1538  			HTTPStatusCode: res.StatusCode,
  1539  		},
  1540  	}
  1541  	target := &ret
  1542  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1543  		return nil, err
  1544  	}
  1545  	return ret, nil
  1546  }
  1547  
  1548  // Pages invokes f for each page of results.
  1549  // A non-nil error returned from f will halt the iteration.
  1550  // The provided context supersedes any context provided to the Context method.
  1551  func (c *ProjectsConfigsListCall) Pages(ctx context.Context, f func(*ListConfigsResponse) error) error {
  1552  	c.ctx_ = ctx
  1553  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  1554  	for {
  1555  		x, err := c.Do()
  1556  		if err != nil {
  1557  			return err
  1558  		}
  1559  		if err := f(x); err != nil {
  1560  			return err
  1561  		}
  1562  		if x.NextPageToken == "" {
  1563  			return nil
  1564  		}
  1565  		c.PageToken(x.NextPageToken)
  1566  	}
  1567  }
  1568  
  1569  type ProjectsConfigsSetIamPolicyCall struct {
  1570  	s                   *Service
  1571  	resource            string
  1572  	setiampolicyrequest *SetIamPolicyRequest
  1573  	urlParams_          gensupport.URLParams
  1574  	ctx_                context.Context
  1575  	header_             http.Header
  1576  }
  1577  
  1578  // SetIamPolicy: Sets the access control policy on the specified resource.
  1579  // Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
  1580  // and `PERMISSION_DENIED` errors.
  1581  //
  1582  //   - resource: REQUIRED: The resource for which the policy is being specified.
  1583  //     See Resource names (https://cloud.google.com/apis/design/resource_names)
  1584  //     for the appropriate value for this field.
  1585  func (r *ProjectsConfigsService) SetIamPolicy(resource string, setiampolicyrequest *SetIamPolicyRequest) *ProjectsConfigsSetIamPolicyCall {
  1586  	c := &ProjectsConfigsSetIamPolicyCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1587  	c.resource = resource
  1588  	c.setiampolicyrequest = setiampolicyrequest
  1589  	return c
  1590  }
  1591  
  1592  // Fields allows partial responses to be retrieved. See
  1593  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1594  // details.
  1595  func (c *ProjectsConfigsSetIamPolicyCall) Fields(s ...googleapi.Field) *ProjectsConfigsSetIamPolicyCall {
  1596  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1597  	return c
  1598  }
  1599  
  1600  // Context sets the context to be used in this call's Do method.
  1601  func (c *ProjectsConfigsSetIamPolicyCall) Context(ctx context.Context) *ProjectsConfigsSetIamPolicyCall {
  1602  	c.ctx_ = ctx
  1603  	return c
  1604  }
  1605  
  1606  // Header returns a http.Header that can be modified by the caller to add
  1607  // headers to the request.
  1608  func (c *ProjectsConfigsSetIamPolicyCall) Header() http.Header {
  1609  	if c.header_ == nil {
  1610  		c.header_ = make(http.Header)
  1611  	}
  1612  	return c.header_
  1613  }
  1614  
  1615  func (c *ProjectsConfigsSetIamPolicyCall) doRequest(alt string) (*http.Response, error) {
  1616  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  1617  	var body io.Reader = nil
  1618  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.setiampolicyrequest)
  1619  	if err != nil {
  1620  		return nil, err
  1621  	}
  1622  	c.urlParams_.Set("alt", alt)
  1623  	c.urlParams_.Set("prettyPrint", "false")
  1624  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:setIamPolicy")
  1625  	urls += "?" + c.urlParams_.Encode()
  1626  	req, err := http.NewRequest("POST", urls, body)
  1627  	if err != nil {
  1628  		return nil, err
  1629  	}
  1630  	req.Header = reqHeaders
  1631  	googleapi.Expand(req.URL, map[string]string{
  1632  		"resource": c.resource,
  1633  	})
  1634  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1635  }
  1636  
  1637  // Do executes the "runtimeconfig.projects.configs.setIamPolicy" call.
  1638  // Any non-2xx status code is an error. Response headers are in either
  1639  // *Policy.ServerResponse.Header or (if a response was returned at all) in
  1640  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1641  // whether the returned error was because http.StatusNotModified was returned.
  1642  func (c *ProjectsConfigsSetIamPolicyCall) Do(opts ...googleapi.CallOption) (*Policy, error) {
  1643  	gensupport.SetOptions(c.urlParams_, opts...)
  1644  	res, err := c.doRequest("json")
  1645  	if res != nil && res.StatusCode == http.StatusNotModified {
  1646  		if res.Body != nil {
  1647  			res.Body.Close()
  1648  		}
  1649  		return nil, gensupport.WrapError(&googleapi.Error{
  1650  			Code:   res.StatusCode,
  1651  			Header: res.Header,
  1652  		})
  1653  	}
  1654  	if err != nil {
  1655  		return nil, err
  1656  	}
  1657  	defer googleapi.CloseBody(res)
  1658  	if err := googleapi.CheckResponse(res); err != nil {
  1659  		return nil, gensupport.WrapError(err)
  1660  	}
  1661  	ret := &Policy{
  1662  		ServerResponse: googleapi.ServerResponse{
  1663  			Header:         res.Header,
  1664  			HTTPStatusCode: res.StatusCode,
  1665  		},
  1666  	}
  1667  	target := &ret
  1668  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1669  		return nil, err
  1670  	}
  1671  	return ret, nil
  1672  }
  1673  
  1674  type ProjectsConfigsTestIamPermissionsCall struct {
  1675  	s                         *Service
  1676  	resource                  string
  1677  	testiampermissionsrequest *TestIamPermissionsRequest
  1678  	urlParams_                gensupport.URLParams
  1679  	ctx_                      context.Context
  1680  	header_                   http.Header
  1681  }
  1682  
  1683  // TestIamPermissions: Returns permissions that a caller has on the specified
  1684  // resource. If the resource does not exist, this will return an empty set of
  1685  // permissions, not a `NOT_FOUND` error. Note: This operation is designed to be
  1686  // used for building permission-aware UIs and command-line tools, not for
  1687  // authorization checking. This operation may "fail open" without warning.
  1688  //
  1689  //   - resource: REQUIRED: The resource for which the policy detail is being
  1690  //     requested. See Resource names
  1691  //     (https://cloud.google.com/apis/design/resource_names) for the appropriate
  1692  //     value for this field.
  1693  func (r *ProjectsConfigsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsConfigsTestIamPermissionsCall {
  1694  	c := &ProjectsConfigsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1695  	c.resource = resource
  1696  	c.testiampermissionsrequest = testiampermissionsrequest
  1697  	return c
  1698  }
  1699  
  1700  // Fields allows partial responses to be retrieved. See
  1701  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1702  // details.
  1703  func (c *ProjectsConfigsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsConfigsTestIamPermissionsCall {
  1704  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1705  	return c
  1706  }
  1707  
  1708  // Context sets the context to be used in this call's Do method.
  1709  func (c *ProjectsConfigsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsConfigsTestIamPermissionsCall {
  1710  	c.ctx_ = ctx
  1711  	return c
  1712  }
  1713  
  1714  // Header returns a http.Header that can be modified by the caller to add
  1715  // headers to the request.
  1716  func (c *ProjectsConfigsTestIamPermissionsCall) Header() http.Header {
  1717  	if c.header_ == nil {
  1718  		c.header_ = make(http.Header)
  1719  	}
  1720  	return c.header_
  1721  }
  1722  
  1723  func (c *ProjectsConfigsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
  1724  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  1725  	var body io.Reader = nil
  1726  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
  1727  	if err != nil {
  1728  		return nil, err
  1729  	}
  1730  	c.urlParams_.Set("alt", alt)
  1731  	c.urlParams_.Set("prettyPrint", "false")
  1732  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:testIamPermissions")
  1733  	urls += "?" + c.urlParams_.Encode()
  1734  	req, err := http.NewRequest("POST", urls, body)
  1735  	if err != nil {
  1736  		return nil, err
  1737  	}
  1738  	req.Header = reqHeaders
  1739  	googleapi.Expand(req.URL, map[string]string{
  1740  		"resource": c.resource,
  1741  	})
  1742  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1743  }
  1744  
  1745  // Do executes the "runtimeconfig.projects.configs.testIamPermissions" call.
  1746  // Any non-2xx status code is an error. Response headers are in either
  1747  // *TestIamPermissionsResponse.ServerResponse.Header or (if a response was
  1748  // returned at all) in error.(*googleapi.Error).Header. Use
  1749  // googleapi.IsNotModified to check whether the returned error was because
  1750  // http.StatusNotModified was returned.
  1751  func (c *ProjectsConfigsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
  1752  	gensupport.SetOptions(c.urlParams_, opts...)
  1753  	res, err := c.doRequest("json")
  1754  	if res != nil && res.StatusCode == http.StatusNotModified {
  1755  		if res.Body != nil {
  1756  			res.Body.Close()
  1757  		}
  1758  		return nil, gensupport.WrapError(&googleapi.Error{
  1759  			Code:   res.StatusCode,
  1760  			Header: res.Header,
  1761  		})
  1762  	}
  1763  	if err != nil {
  1764  		return nil, err
  1765  	}
  1766  	defer googleapi.CloseBody(res)
  1767  	if err := googleapi.CheckResponse(res); err != nil {
  1768  		return nil, gensupport.WrapError(err)
  1769  	}
  1770  	ret := &TestIamPermissionsResponse{
  1771  		ServerResponse: googleapi.ServerResponse{
  1772  			Header:         res.Header,
  1773  			HTTPStatusCode: res.StatusCode,
  1774  		},
  1775  	}
  1776  	target := &ret
  1777  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1778  		return nil, err
  1779  	}
  1780  	return ret, nil
  1781  }
  1782  
  1783  type ProjectsConfigsUpdateCall struct {
  1784  	s             *Service
  1785  	name          string
  1786  	runtimeconfig *RuntimeConfig
  1787  	urlParams_    gensupport.URLParams
  1788  	ctx_          context.Context
  1789  	header_       http.Header
  1790  }
  1791  
  1792  // Update: Updates a RuntimeConfig resource. The configuration must exist
  1793  // beforehand.
  1794  //
  1795  //   - name: The name of the RuntimeConfig resource to update, in the format:
  1796  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  1797  func (r *ProjectsConfigsService) Update(name string, runtimeconfig *RuntimeConfig) *ProjectsConfigsUpdateCall {
  1798  	c := &ProjectsConfigsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1799  	c.name = name
  1800  	c.runtimeconfig = runtimeconfig
  1801  	return c
  1802  }
  1803  
  1804  // Fields allows partial responses to be retrieved. See
  1805  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1806  // details.
  1807  func (c *ProjectsConfigsUpdateCall) Fields(s ...googleapi.Field) *ProjectsConfigsUpdateCall {
  1808  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1809  	return c
  1810  }
  1811  
  1812  // Context sets the context to be used in this call's Do method.
  1813  func (c *ProjectsConfigsUpdateCall) Context(ctx context.Context) *ProjectsConfigsUpdateCall {
  1814  	c.ctx_ = ctx
  1815  	return c
  1816  }
  1817  
  1818  // Header returns a http.Header that can be modified by the caller to add
  1819  // headers to the request.
  1820  func (c *ProjectsConfigsUpdateCall) Header() http.Header {
  1821  	if c.header_ == nil {
  1822  		c.header_ = make(http.Header)
  1823  	}
  1824  	return c.header_
  1825  }
  1826  
  1827  func (c *ProjectsConfigsUpdateCall) doRequest(alt string) (*http.Response, error) {
  1828  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  1829  	var body io.Reader = nil
  1830  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.runtimeconfig)
  1831  	if err != nil {
  1832  		return nil, err
  1833  	}
  1834  	c.urlParams_.Set("alt", alt)
  1835  	c.urlParams_.Set("prettyPrint", "false")
  1836  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  1837  	urls += "?" + c.urlParams_.Encode()
  1838  	req, err := http.NewRequest("PUT", urls, body)
  1839  	if err != nil {
  1840  		return nil, err
  1841  	}
  1842  	req.Header = reqHeaders
  1843  	googleapi.Expand(req.URL, map[string]string{
  1844  		"name": c.name,
  1845  	})
  1846  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1847  }
  1848  
  1849  // Do executes the "runtimeconfig.projects.configs.update" call.
  1850  // Any non-2xx status code is an error. Response headers are in either
  1851  // *RuntimeConfig.ServerResponse.Header or (if a response was returned at all)
  1852  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1853  // whether the returned error was because http.StatusNotModified was returned.
  1854  func (c *ProjectsConfigsUpdateCall) Do(opts ...googleapi.CallOption) (*RuntimeConfig, error) {
  1855  	gensupport.SetOptions(c.urlParams_, opts...)
  1856  	res, err := c.doRequest("json")
  1857  	if res != nil && res.StatusCode == http.StatusNotModified {
  1858  		if res.Body != nil {
  1859  			res.Body.Close()
  1860  		}
  1861  		return nil, gensupport.WrapError(&googleapi.Error{
  1862  			Code:   res.StatusCode,
  1863  			Header: res.Header,
  1864  		})
  1865  	}
  1866  	if err != nil {
  1867  		return nil, err
  1868  	}
  1869  	defer googleapi.CloseBody(res)
  1870  	if err := googleapi.CheckResponse(res); err != nil {
  1871  		return nil, gensupport.WrapError(err)
  1872  	}
  1873  	ret := &RuntimeConfig{
  1874  		ServerResponse: googleapi.ServerResponse{
  1875  			Header:         res.Header,
  1876  			HTTPStatusCode: res.StatusCode,
  1877  		},
  1878  	}
  1879  	target := &ret
  1880  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1881  		return nil, err
  1882  	}
  1883  	return ret, nil
  1884  }
  1885  
  1886  type ProjectsConfigsOperationsGetCall struct {
  1887  	s            *Service
  1888  	name         string
  1889  	urlParams_   gensupport.URLParams
  1890  	ifNoneMatch_ string
  1891  	ctx_         context.Context
  1892  	header_      http.Header
  1893  }
  1894  
  1895  // Get: Gets the latest state of a long-running operation. Clients can use this
  1896  // method to poll the operation result at intervals as recommended by the API
  1897  // service.
  1898  //
  1899  // - name: The name of the operation resource.
  1900  func (r *ProjectsConfigsOperationsService) Get(name string) *ProjectsConfigsOperationsGetCall {
  1901  	c := &ProjectsConfigsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1902  	c.name = name
  1903  	return c
  1904  }
  1905  
  1906  // Fields allows partial responses to be retrieved. See
  1907  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1908  // details.
  1909  func (c *ProjectsConfigsOperationsGetCall) Fields(s ...googleapi.Field) *ProjectsConfigsOperationsGetCall {
  1910  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1911  	return c
  1912  }
  1913  
  1914  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  1915  // object's ETag matches the given value. This is useful for getting updates
  1916  // only after the object has changed since the last request.
  1917  func (c *ProjectsConfigsOperationsGetCall) IfNoneMatch(entityTag string) *ProjectsConfigsOperationsGetCall {
  1918  	c.ifNoneMatch_ = entityTag
  1919  	return c
  1920  }
  1921  
  1922  // Context sets the context to be used in this call's Do method.
  1923  func (c *ProjectsConfigsOperationsGetCall) Context(ctx context.Context) *ProjectsConfigsOperationsGetCall {
  1924  	c.ctx_ = ctx
  1925  	return c
  1926  }
  1927  
  1928  // Header returns a http.Header that can be modified by the caller to add
  1929  // headers to the request.
  1930  func (c *ProjectsConfigsOperationsGetCall) Header() http.Header {
  1931  	if c.header_ == nil {
  1932  		c.header_ = make(http.Header)
  1933  	}
  1934  	return c.header_
  1935  }
  1936  
  1937  func (c *ProjectsConfigsOperationsGetCall) doRequest(alt string) (*http.Response, error) {
  1938  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1939  	if c.ifNoneMatch_ != "" {
  1940  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1941  	}
  1942  	var body io.Reader = nil
  1943  	c.urlParams_.Set("alt", alt)
  1944  	c.urlParams_.Set("prettyPrint", "false")
  1945  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  1946  	urls += "?" + c.urlParams_.Encode()
  1947  	req, err := http.NewRequest("GET", urls, body)
  1948  	if err != nil {
  1949  		return nil, err
  1950  	}
  1951  	req.Header = reqHeaders
  1952  	googleapi.Expand(req.URL, map[string]string{
  1953  		"name": c.name,
  1954  	})
  1955  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1956  }
  1957  
  1958  // Do executes the "runtimeconfig.projects.configs.operations.get" call.
  1959  // Any non-2xx status code is an error. Response headers are in either
  1960  // *Operation.ServerResponse.Header or (if a response was returned at all) in
  1961  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  1962  // whether the returned error was because http.StatusNotModified was returned.
  1963  func (c *ProjectsConfigsOperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
  1964  	gensupport.SetOptions(c.urlParams_, opts...)
  1965  	res, err := c.doRequest("json")
  1966  	if res != nil && res.StatusCode == http.StatusNotModified {
  1967  		if res.Body != nil {
  1968  			res.Body.Close()
  1969  		}
  1970  		return nil, gensupport.WrapError(&googleapi.Error{
  1971  			Code:   res.StatusCode,
  1972  			Header: res.Header,
  1973  		})
  1974  	}
  1975  	if err != nil {
  1976  		return nil, err
  1977  	}
  1978  	defer googleapi.CloseBody(res)
  1979  	if err := googleapi.CheckResponse(res); err != nil {
  1980  		return nil, gensupport.WrapError(err)
  1981  	}
  1982  	ret := &Operation{
  1983  		ServerResponse: googleapi.ServerResponse{
  1984  			Header:         res.Header,
  1985  			HTTPStatusCode: res.StatusCode,
  1986  		},
  1987  	}
  1988  	target := &ret
  1989  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1990  		return nil, err
  1991  	}
  1992  	return ret, nil
  1993  }
  1994  
  1995  type ProjectsConfigsOperationsTestIamPermissionsCall struct {
  1996  	s                         *Service
  1997  	resource                  string
  1998  	testiampermissionsrequest *TestIamPermissionsRequest
  1999  	urlParams_                gensupport.URLParams
  2000  	ctx_                      context.Context
  2001  	header_                   http.Header
  2002  }
  2003  
  2004  // TestIamPermissions: Returns permissions that a caller has on the specified
  2005  // resource. If the resource does not exist, this will return an empty set of
  2006  // permissions, not a `NOT_FOUND` error. Note: This operation is designed to be
  2007  // used for building permission-aware UIs and command-line tools, not for
  2008  // authorization checking. This operation may "fail open" without warning.
  2009  //
  2010  //   - resource: REQUIRED: The resource for which the policy detail is being
  2011  //     requested. See Resource names
  2012  //     (https://cloud.google.com/apis/design/resource_names) for the appropriate
  2013  //     value for this field.
  2014  func (r *ProjectsConfigsOperationsService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsConfigsOperationsTestIamPermissionsCall {
  2015  	c := &ProjectsConfigsOperationsTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2016  	c.resource = resource
  2017  	c.testiampermissionsrequest = testiampermissionsrequest
  2018  	return c
  2019  }
  2020  
  2021  // Fields allows partial responses to be retrieved. See
  2022  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2023  // details.
  2024  func (c *ProjectsConfigsOperationsTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsConfigsOperationsTestIamPermissionsCall {
  2025  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2026  	return c
  2027  }
  2028  
  2029  // Context sets the context to be used in this call's Do method.
  2030  func (c *ProjectsConfigsOperationsTestIamPermissionsCall) Context(ctx context.Context) *ProjectsConfigsOperationsTestIamPermissionsCall {
  2031  	c.ctx_ = ctx
  2032  	return c
  2033  }
  2034  
  2035  // Header returns a http.Header that can be modified by the caller to add
  2036  // headers to the request.
  2037  func (c *ProjectsConfigsOperationsTestIamPermissionsCall) Header() http.Header {
  2038  	if c.header_ == nil {
  2039  		c.header_ = make(http.Header)
  2040  	}
  2041  	return c.header_
  2042  }
  2043  
  2044  func (c *ProjectsConfigsOperationsTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
  2045  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2046  	var body io.Reader = nil
  2047  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
  2048  	if err != nil {
  2049  		return nil, err
  2050  	}
  2051  	c.urlParams_.Set("alt", alt)
  2052  	c.urlParams_.Set("prettyPrint", "false")
  2053  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:testIamPermissions")
  2054  	urls += "?" + c.urlParams_.Encode()
  2055  	req, err := http.NewRequest("POST", urls, body)
  2056  	if err != nil {
  2057  		return nil, err
  2058  	}
  2059  	req.Header = reqHeaders
  2060  	googleapi.Expand(req.URL, map[string]string{
  2061  		"resource": c.resource,
  2062  	})
  2063  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2064  }
  2065  
  2066  // Do executes the "runtimeconfig.projects.configs.operations.testIamPermissions" call.
  2067  // Any non-2xx status code is an error. Response headers are in either
  2068  // *TestIamPermissionsResponse.ServerResponse.Header or (if a response was
  2069  // returned at all) in error.(*googleapi.Error).Header. Use
  2070  // googleapi.IsNotModified to check whether the returned error was because
  2071  // http.StatusNotModified was returned.
  2072  func (c *ProjectsConfigsOperationsTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
  2073  	gensupport.SetOptions(c.urlParams_, opts...)
  2074  	res, err := c.doRequest("json")
  2075  	if res != nil && res.StatusCode == http.StatusNotModified {
  2076  		if res.Body != nil {
  2077  			res.Body.Close()
  2078  		}
  2079  		return nil, gensupport.WrapError(&googleapi.Error{
  2080  			Code:   res.StatusCode,
  2081  			Header: res.Header,
  2082  		})
  2083  	}
  2084  	if err != nil {
  2085  		return nil, err
  2086  	}
  2087  	defer googleapi.CloseBody(res)
  2088  	if err := googleapi.CheckResponse(res); err != nil {
  2089  		return nil, gensupport.WrapError(err)
  2090  	}
  2091  	ret := &TestIamPermissionsResponse{
  2092  		ServerResponse: googleapi.ServerResponse{
  2093  			Header:         res.Header,
  2094  			HTTPStatusCode: res.StatusCode,
  2095  		},
  2096  	}
  2097  	target := &ret
  2098  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2099  		return nil, err
  2100  	}
  2101  	return ret, nil
  2102  }
  2103  
  2104  type ProjectsConfigsVariablesCreateCall struct {
  2105  	s          *Service
  2106  	parent     string
  2107  	variable   *Variable
  2108  	urlParams_ gensupport.URLParams
  2109  	ctx_       context.Context
  2110  	header_    http.Header
  2111  }
  2112  
  2113  // Create: Creates a variable within the given configuration. You cannot create
  2114  // a variable with a name that is a prefix of an existing variable name, or a
  2115  // name that has an existing variable name as a prefix. To learn more about
  2116  // creating a variable, read the Setting and Getting Data
  2117  // (/deployment-manager/runtime-configurator/set-and-get-variables)
  2118  // documentation.
  2119  //
  2120  //   - parent: The path to the RutimeConfig resource that this variable should
  2121  //     belong to. The configuration must exist beforehand; the path must be in
  2122  //     the format: `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  2123  func (r *ProjectsConfigsVariablesService) Create(parent string, variable *Variable) *ProjectsConfigsVariablesCreateCall {
  2124  	c := &ProjectsConfigsVariablesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2125  	c.parent = parent
  2126  	c.variable = variable
  2127  	return c
  2128  }
  2129  
  2130  // RequestId sets the optional parameter "requestId": An optional but
  2131  // recommended unique `request_id`. If the server receives two `create()`
  2132  // requests with the same `request_id`, then the second request will be ignored
  2133  // and the first resource created and stored in the backend is returned. Empty
  2134  // `request_id` fields are ignored. It is responsibility of the client to
  2135  // ensure uniqueness of the `request_id` strings. `request_id` strings are
  2136  // limited to 64 characters.
  2137  func (c *ProjectsConfigsVariablesCreateCall) RequestId(requestId string) *ProjectsConfigsVariablesCreateCall {
  2138  	c.urlParams_.Set("requestId", requestId)
  2139  	return c
  2140  }
  2141  
  2142  // Fields allows partial responses to be retrieved. See
  2143  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2144  // details.
  2145  func (c *ProjectsConfigsVariablesCreateCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesCreateCall {
  2146  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2147  	return c
  2148  }
  2149  
  2150  // Context sets the context to be used in this call's Do method.
  2151  func (c *ProjectsConfigsVariablesCreateCall) Context(ctx context.Context) *ProjectsConfigsVariablesCreateCall {
  2152  	c.ctx_ = ctx
  2153  	return c
  2154  }
  2155  
  2156  // Header returns a http.Header that can be modified by the caller to add
  2157  // headers to the request.
  2158  func (c *ProjectsConfigsVariablesCreateCall) Header() http.Header {
  2159  	if c.header_ == nil {
  2160  		c.header_ = make(http.Header)
  2161  	}
  2162  	return c.header_
  2163  }
  2164  
  2165  func (c *ProjectsConfigsVariablesCreateCall) doRequest(alt string) (*http.Response, error) {
  2166  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2167  	var body io.Reader = nil
  2168  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.variable)
  2169  	if err != nil {
  2170  		return nil, err
  2171  	}
  2172  	c.urlParams_.Set("alt", alt)
  2173  	c.urlParams_.Set("prettyPrint", "false")
  2174  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/variables")
  2175  	urls += "?" + c.urlParams_.Encode()
  2176  	req, err := http.NewRequest("POST", urls, body)
  2177  	if err != nil {
  2178  		return nil, err
  2179  	}
  2180  	req.Header = reqHeaders
  2181  	googleapi.Expand(req.URL, map[string]string{
  2182  		"parent": c.parent,
  2183  	})
  2184  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2185  }
  2186  
  2187  // Do executes the "runtimeconfig.projects.configs.variables.create" call.
  2188  // Any non-2xx status code is an error. Response headers are in either
  2189  // *Variable.ServerResponse.Header or (if a response was returned at all) in
  2190  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2191  // whether the returned error was because http.StatusNotModified was returned.
  2192  func (c *ProjectsConfigsVariablesCreateCall) Do(opts ...googleapi.CallOption) (*Variable, error) {
  2193  	gensupport.SetOptions(c.urlParams_, opts...)
  2194  	res, err := c.doRequest("json")
  2195  	if res != nil && res.StatusCode == http.StatusNotModified {
  2196  		if res.Body != nil {
  2197  			res.Body.Close()
  2198  		}
  2199  		return nil, gensupport.WrapError(&googleapi.Error{
  2200  			Code:   res.StatusCode,
  2201  			Header: res.Header,
  2202  		})
  2203  	}
  2204  	if err != nil {
  2205  		return nil, err
  2206  	}
  2207  	defer googleapi.CloseBody(res)
  2208  	if err := googleapi.CheckResponse(res); err != nil {
  2209  		return nil, gensupport.WrapError(err)
  2210  	}
  2211  	ret := &Variable{
  2212  		ServerResponse: googleapi.ServerResponse{
  2213  			Header:         res.Header,
  2214  			HTTPStatusCode: res.StatusCode,
  2215  		},
  2216  	}
  2217  	target := &ret
  2218  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2219  		return nil, err
  2220  	}
  2221  	return ret, nil
  2222  }
  2223  
  2224  type ProjectsConfigsVariablesDeleteCall struct {
  2225  	s          *Service
  2226  	name       string
  2227  	urlParams_ gensupport.URLParams
  2228  	ctx_       context.Context
  2229  	header_    http.Header
  2230  }
  2231  
  2232  // Delete: Deletes a variable or multiple variables. If you specify a variable
  2233  // name, then that variable is deleted. If you specify a prefix and `recursive`
  2234  // is true, then all variables with that prefix are deleted. You must set a
  2235  // `recursive` to true if you delete variables by prefix.
  2236  //
  2237  //   - name: The name of the variable to delete, in the format:
  2238  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/variables/[VARIABLE_NAME]`.
  2239  func (r *ProjectsConfigsVariablesService) Delete(name string) *ProjectsConfigsVariablesDeleteCall {
  2240  	c := &ProjectsConfigsVariablesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2241  	c.name = name
  2242  	return c
  2243  }
  2244  
  2245  // Recursive sets the optional parameter "recursive": Set to `true` to
  2246  // recursively delete multiple variables with the same prefix.
  2247  func (c *ProjectsConfigsVariablesDeleteCall) Recursive(recursive bool) *ProjectsConfigsVariablesDeleteCall {
  2248  	c.urlParams_.Set("recursive", fmt.Sprint(recursive))
  2249  	return c
  2250  }
  2251  
  2252  // Fields allows partial responses to be retrieved. See
  2253  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2254  // details.
  2255  func (c *ProjectsConfigsVariablesDeleteCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesDeleteCall {
  2256  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2257  	return c
  2258  }
  2259  
  2260  // Context sets the context to be used in this call's Do method.
  2261  func (c *ProjectsConfigsVariablesDeleteCall) Context(ctx context.Context) *ProjectsConfigsVariablesDeleteCall {
  2262  	c.ctx_ = ctx
  2263  	return c
  2264  }
  2265  
  2266  // Header returns a http.Header that can be modified by the caller to add
  2267  // headers to the request.
  2268  func (c *ProjectsConfigsVariablesDeleteCall) Header() http.Header {
  2269  	if c.header_ == nil {
  2270  		c.header_ = make(http.Header)
  2271  	}
  2272  	return c.header_
  2273  }
  2274  
  2275  func (c *ProjectsConfigsVariablesDeleteCall) doRequest(alt string) (*http.Response, error) {
  2276  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2277  	var body io.Reader = nil
  2278  	c.urlParams_.Set("alt", alt)
  2279  	c.urlParams_.Set("prettyPrint", "false")
  2280  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  2281  	urls += "?" + c.urlParams_.Encode()
  2282  	req, err := http.NewRequest("DELETE", urls, body)
  2283  	if err != nil {
  2284  		return nil, err
  2285  	}
  2286  	req.Header = reqHeaders
  2287  	googleapi.Expand(req.URL, map[string]string{
  2288  		"name": c.name,
  2289  	})
  2290  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2291  }
  2292  
  2293  // Do executes the "runtimeconfig.projects.configs.variables.delete" call.
  2294  // Any non-2xx status code is an error. Response headers are in either
  2295  // *Empty.ServerResponse.Header or (if a response was returned at all) in
  2296  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2297  // whether the returned error was because http.StatusNotModified was returned.
  2298  func (c *ProjectsConfigsVariablesDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  2299  	gensupport.SetOptions(c.urlParams_, opts...)
  2300  	res, err := c.doRequest("json")
  2301  	if res != nil && res.StatusCode == http.StatusNotModified {
  2302  		if res.Body != nil {
  2303  			res.Body.Close()
  2304  		}
  2305  		return nil, gensupport.WrapError(&googleapi.Error{
  2306  			Code:   res.StatusCode,
  2307  			Header: res.Header,
  2308  		})
  2309  	}
  2310  	if err != nil {
  2311  		return nil, err
  2312  	}
  2313  	defer googleapi.CloseBody(res)
  2314  	if err := googleapi.CheckResponse(res); err != nil {
  2315  		return nil, gensupport.WrapError(err)
  2316  	}
  2317  	ret := &Empty{
  2318  		ServerResponse: googleapi.ServerResponse{
  2319  			Header:         res.Header,
  2320  			HTTPStatusCode: res.StatusCode,
  2321  		},
  2322  	}
  2323  	target := &ret
  2324  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2325  		return nil, err
  2326  	}
  2327  	return ret, nil
  2328  }
  2329  
  2330  type ProjectsConfigsVariablesGetCall struct {
  2331  	s            *Service
  2332  	name         string
  2333  	urlParams_   gensupport.URLParams
  2334  	ifNoneMatch_ string
  2335  	ctx_         context.Context
  2336  	header_      http.Header
  2337  }
  2338  
  2339  // Get: Gets information about a single variable.
  2340  //
  2341  //   - name: The name of the variable to return, in the format:
  2342  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/variables/[VARIBLE_NAME]`.
  2343  func (r *ProjectsConfigsVariablesService) Get(name string) *ProjectsConfigsVariablesGetCall {
  2344  	c := &ProjectsConfigsVariablesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2345  	c.name = name
  2346  	return c
  2347  }
  2348  
  2349  // Fields allows partial responses to be retrieved. See
  2350  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2351  // details.
  2352  func (c *ProjectsConfigsVariablesGetCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesGetCall {
  2353  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2354  	return c
  2355  }
  2356  
  2357  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  2358  // object's ETag matches the given value. This is useful for getting updates
  2359  // only after the object has changed since the last request.
  2360  func (c *ProjectsConfigsVariablesGetCall) IfNoneMatch(entityTag string) *ProjectsConfigsVariablesGetCall {
  2361  	c.ifNoneMatch_ = entityTag
  2362  	return c
  2363  }
  2364  
  2365  // Context sets the context to be used in this call's Do method.
  2366  func (c *ProjectsConfigsVariablesGetCall) Context(ctx context.Context) *ProjectsConfigsVariablesGetCall {
  2367  	c.ctx_ = ctx
  2368  	return c
  2369  }
  2370  
  2371  // Header returns a http.Header that can be modified by the caller to add
  2372  // headers to the request.
  2373  func (c *ProjectsConfigsVariablesGetCall) Header() http.Header {
  2374  	if c.header_ == nil {
  2375  		c.header_ = make(http.Header)
  2376  	}
  2377  	return c.header_
  2378  }
  2379  
  2380  func (c *ProjectsConfigsVariablesGetCall) doRequest(alt string) (*http.Response, error) {
  2381  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2382  	if c.ifNoneMatch_ != "" {
  2383  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2384  	}
  2385  	var body io.Reader = nil
  2386  	c.urlParams_.Set("alt", alt)
  2387  	c.urlParams_.Set("prettyPrint", "false")
  2388  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  2389  	urls += "?" + c.urlParams_.Encode()
  2390  	req, err := http.NewRequest("GET", urls, body)
  2391  	if err != nil {
  2392  		return nil, err
  2393  	}
  2394  	req.Header = reqHeaders
  2395  	googleapi.Expand(req.URL, map[string]string{
  2396  		"name": c.name,
  2397  	})
  2398  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2399  }
  2400  
  2401  // Do executes the "runtimeconfig.projects.configs.variables.get" call.
  2402  // Any non-2xx status code is an error. Response headers are in either
  2403  // *Variable.ServerResponse.Header or (if a response was returned at all) in
  2404  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2405  // whether the returned error was because http.StatusNotModified was returned.
  2406  func (c *ProjectsConfigsVariablesGetCall) Do(opts ...googleapi.CallOption) (*Variable, error) {
  2407  	gensupport.SetOptions(c.urlParams_, opts...)
  2408  	res, err := c.doRequest("json")
  2409  	if res != nil && res.StatusCode == http.StatusNotModified {
  2410  		if res.Body != nil {
  2411  			res.Body.Close()
  2412  		}
  2413  		return nil, gensupport.WrapError(&googleapi.Error{
  2414  			Code:   res.StatusCode,
  2415  			Header: res.Header,
  2416  		})
  2417  	}
  2418  	if err != nil {
  2419  		return nil, err
  2420  	}
  2421  	defer googleapi.CloseBody(res)
  2422  	if err := googleapi.CheckResponse(res); err != nil {
  2423  		return nil, gensupport.WrapError(err)
  2424  	}
  2425  	ret := &Variable{
  2426  		ServerResponse: googleapi.ServerResponse{
  2427  			Header:         res.Header,
  2428  			HTTPStatusCode: res.StatusCode,
  2429  		},
  2430  	}
  2431  	target := &ret
  2432  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2433  		return nil, err
  2434  	}
  2435  	return ret, nil
  2436  }
  2437  
  2438  type ProjectsConfigsVariablesListCall struct {
  2439  	s            *Service
  2440  	parent       string
  2441  	urlParams_   gensupport.URLParams
  2442  	ifNoneMatch_ string
  2443  	ctx_         context.Context
  2444  	header_      http.Header
  2445  }
  2446  
  2447  // List: Lists variables within given a configuration, matching any provided
  2448  // filters. This only lists variable names, not the values, unless
  2449  // `return_values` is true, in which case only variables that user has IAM
  2450  // permission to GetVariable will be returned.
  2451  //
  2452  //   - parent: The path to the RuntimeConfig resource for which you want to list
  2453  //     variables. The configuration must exist beforehand; the path must be in
  2454  //     the format: `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  2455  func (r *ProjectsConfigsVariablesService) List(parent string) *ProjectsConfigsVariablesListCall {
  2456  	c := &ProjectsConfigsVariablesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2457  	c.parent = parent
  2458  	return c
  2459  }
  2460  
  2461  // Filter sets the optional parameter "filter": Filters variables by matching
  2462  // the specified filter. For example:
  2463  // `projects/example-project/config/[CONFIG_NAME]/variables/example-variable`.
  2464  func (c *ProjectsConfigsVariablesListCall) Filter(filter string) *ProjectsConfigsVariablesListCall {
  2465  	c.urlParams_.Set("filter", filter)
  2466  	return c
  2467  }
  2468  
  2469  // PageSize sets the optional parameter "pageSize": Specifies the number of
  2470  // results to return per page. If there are fewer elements than the specified
  2471  // number, returns all elements.
  2472  func (c *ProjectsConfigsVariablesListCall) PageSize(pageSize int64) *ProjectsConfigsVariablesListCall {
  2473  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  2474  	return c
  2475  }
  2476  
  2477  // PageToken sets the optional parameter "pageToken": Specifies a page token to
  2478  // use. Set `pageToken` to a `nextPageToken` returned by a previous list
  2479  // request to get the next page of results.
  2480  func (c *ProjectsConfigsVariablesListCall) PageToken(pageToken string) *ProjectsConfigsVariablesListCall {
  2481  	c.urlParams_.Set("pageToken", pageToken)
  2482  	return c
  2483  }
  2484  
  2485  // ReturnValues sets the optional parameter "returnValues": The flag indicates
  2486  // whether the user wants to return values of variables. If true, then only
  2487  // those variables that user has IAM GetVariable permission will be returned
  2488  // along with their values.
  2489  func (c *ProjectsConfigsVariablesListCall) ReturnValues(returnValues bool) *ProjectsConfigsVariablesListCall {
  2490  	c.urlParams_.Set("returnValues", fmt.Sprint(returnValues))
  2491  	return c
  2492  }
  2493  
  2494  // Fields allows partial responses to be retrieved. See
  2495  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2496  // details.
  2497  func (c *ProjectsConfigsVariablesListCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesListCall {
  2498  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2499  	return c
  2500  }
  2501  
  2502  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  2503  // object's ETag matches the given value. This is useful for getting updates
  2504  // only after the object has changed since the last request.
  2505  func (c *ProjectsConfigsVariablesListCall) IfNoneMatch(entityTag string) *ProjectsConfigsVariablesListCall {
  2506  	c.ifNoneMatch_ = entityTag
  2507  	return c
  2508  }
  2509  
  2510  // Context sets the context to be used in this call's Do method.
  2511  func (c *ProjectsConfigsVariablesListCall) Context(ctx context.Context) *ProjectsConfigsVariablesListCall {
  2512  	c.ctx_ = ctx
  2513  	return c
  2514  }
  2515  
  2516  // Header returns a http.Header that can be modified by the caller to add
  2517  // headers to the request.
  2518  func (c *ProjectsConfigsVariablesListCall) Header() http.Header {
  2519  	if c.header_ == nil {
  2520  		c.header_ = make(http.Header)
  2521  	}
  2522  	return c.header_
  2523  }
  2524  
  2525  func (c *ProjectsConfigsVariablesListCall) doRequest(alt string) (*http.Response, error) {
  2526  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2527  	if c.ifNoneMatch_ != "" {
  2528  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2529  	}
  2530  	var body io.Reader = nil
  2531  	c.urlParams_.Set("alt", alt)
  2532  	c.urlParams_.Set("prettyPrint", "false")
  2533  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/variables")
  2534  	urls += "?" + c.urlParams_.Encode()
  2535  	req, err := http.NewRequest("GET", urls, body)
  2536  	if err != nil {
  2537  		return nil, err
  2538  	}
  2539  	req.Header = reqHeaders
  2540  	googleapi.Expand(req.URL, map[string]string{
  2541  		"parent": c.parent,
  2542  	})
  2543  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2544  }
  2545  
  2546  // Do executes the "runtimeconfig.projects.configs.variables.list" call.
  2547  // Any non-2xx status code is an error. Response headers are in either
  2548  // *ListVariablesResponse.ServerResponse.Header or (if a response was returned
  2549  // at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2550  // check whether the returned error was because http.StatusNotModified was
  2551  // returned.
  2552  func (c *ProjectsConfigsVariablesListCall) Do(opts ...googleapi.CallOption) (*ListVariablesResponse, error) {
  2553  	gensupport.SetOptions(c.urlParams_, opts...)
  2554  	res, err := c.doRequest("json")
  2555  	if res != nil && res.StatusCode == http.StatusNotModified {
  2556  		if res.Body != nil {
  2557  			res.Body.Close()
  2558  		}
  2559  		return nil, gensupport.WrapError(&googleapi.Error{
  2560  			Code:   res.StatusCode,
  2561  			Header: res.Header,
  2562  		})
  2563  	}
  2564  	if err != nil {
  2565  		return nil, err
  2566  	}
  2567  	defer googleapi.CloseBody(res)
  2568  	if err := googleapi.CheckResponse(res); err != nil {
  2569  		return nil, gensupport.WrapError(err)
  2570  	}
  2571  	ret := &ListVariablesResponse{
  2572  		ServerResponse: googleapi.ServerResponse{
  2573  			Header:         res.Header,
  2574  			HTTPStatusCode: res.StatusCode,
  2575  		},
  2576  	}
  2577  	target := &ret
  2578  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2579  		return nil, err
  2580  	}
  2581  	return ret, nil
  2582  }
  2583  
  2584  // Pages invokes f for each page of results.
  2585  // A non-nil error returned from f will halt the iteration.
  2586  // The provided context supersedes any context provided to the Context method.
  2587  func (c *ProjectsConfigsVariablesListCall) Pages(ctx context.Context, f func(*ListVariablesResponse) error) error {
  2588  	c.ctx_ = ctx
  2589  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  2590  	for {
  2591  		x, err := c.Do()
  2592  		if err != nil {
  2593  			return err
  2594  		}
  2595  		if err := f(x); err != nil {
  2596  			return err
  2597  		}
  2598  		if x.NextPageToken == "" {
  2599  			return nil
  2600  		}
  2601  		c.PageToken(x.NextPageToken)
  2602  	}
  2603  }
  2604  
  2605  type ProjectsConfigsVariablesTestIamPermissionsCall struct {
  2606  	s                         *Service
  2607  	resource                  string
  2608  	testiampermissionsrequest *TestIamPermissionsRequest
  2609  	urlParams_                gensupport.URLParams
  2610  	ctx_                      context.Context
  2611  	header_                   http.Header
  2612  }
  2613  
  2614  // TestIamPermissions: Returns permissions that a caller has on the specified
  2615  // resource. If the resource does not exist, this will return an empty set of
  2616  // permissions, not a `NOT_FOUND` error. Note: This operation is designed to be
  2617  // used for building permission-aware UIs and command-line tools, not for
  2618  // authorization checking. This operation may "fail open" without warning.
  2619  //
  2620  //   - resource: REQUIRED: The resource for which the policy detail is being
  2621  //     requested. See Resource names
  2622  //     (https://cloud.google.com/apis/design/resource_names) for the appropriate
  2623  //     value for this field.
  2624  func (r *ProjectsConfigsVariablesService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsConfigsVariablesTestIamPermissionsCall {
  2625  	c := &ProjectsConfigsVariablesTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2626  	c.resource = resource
  2627  	c.testiampermissionsrequest = testiampermissionsrequest
  2628  	return c
  2629  }
  2630  
  2631  // Fields allows partial responses to be retrieved. See
  2632  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2633  // details.
  2634  func (c *ProjectsConfigsVariablesTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesTestIamPermissionsCall {
  2635  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2636  	return c
  2637  }
  2638  
  2639  // Context sets the context to be used in this call's Do method.
  2640  func (c *ProjectsConfigsVariablesTestIamPermissionsCall) Context(ctx context.Context) *ProjectsConfigsVariablesTestIamPermissionsCall {
  2641  	c.ctx_ = ctx
  2642  	return c
  2643  }
  2644  
  2645  // Header returns a http.Header that can be modified by the caller to add
  2646  // headers to the request.
  2647  func (c *ProjectsConfigsVariablesTestIamPermissionsCall) Header() http.Header {
  2648  	if c.header_ == nil {
  2649  		c.header_ = make(http.Header)
  2650  	}
  2651  	return c.header_
  2652  }
  2653  
  2654  func (c *ProjectsConfigsVariablesTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
  2655  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2656  	var body io.Reader = nil
  2657  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
  2658  	if err != nil {
  2659  		return nil, err
  2660  	}
  2661  	c.urlParams_.Set("alt", alt)
  2662  	c.urlParams_.Set("prettyPrint", "false")
  2663  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:testIamPermissions")
  2664  	urls += "?" + c.urlParams_.Encode()
  2665  	req, err := http.NewRequest("POST", urls, body)
  2666  	if err != nil {
  2667  		return nil, err
  2668  	}
  2669  	req.Header = reqHeaders
  2670  	googleapi.Expand(req.URL, map[string]string{
  2671  		"resource": c.resource,
  2672  	})
  2673  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2674  }
  2675  
  2676  // Do executes the "runtimeconfig.projects.configs.variables.testIamPermissions" call.
  2677  // Any non-2xx status code is an error. Response headers are in either
  2678  // *TestIamPermissionsResponse.ServerResponse.Header or (if a response was
  2679  // returned at all) in error.(*googleapi.Error).Header. Use
  2680  // googleapi.IsNotModified to check whether the returned error was because
  2681  // http.StatusNotModified was returned.
  2682  func (c *ProjectsConfigsVariablesTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
  2683  	gensupport.SetOptions(c.urlParams_, opts...)
  2684  	res, err := c.doRequest("json")
  2685  	if res != nil && res.StatusCode == http.StatusNotModified {
  2686  		if res.Body != nil {
  2687  			res.Body.Close()
  2688  		}
  2689  		return nil, gensupport.WrapError(&googleapi.Error{
  2690  			Code:   res.StatusCode,
  2691  			Header: res.Header,
  2692  		})
  2693  	}
  2694  	if err != nil {
  2695  		return nil, err
  2696  	}
  2697  	defer googleapi.CloseBody(res)
  2698  	if err := googleapi.CheckResponse(res); err != nil {
  2699  		return nil, gensupport.WrapError(err)
  2700  	}
  2701  	ret := &TestIamPermissionsResponse{
  2702  		ServerResponse: googleapi.ServerResponse{
  2703  			Header:         res.Header,
  2704  			HTTPStatusCode: res.StatusCode,
  2705  		},
  2706  	}
  2707  	target := &ret
  2708  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2709  		return nil, err
  2710  	}
  2711  	return ret, nil
  2712  }
  2713  
  2714  type ProjectsConfigsVariablesUpdateCall struct {
  2715  	s          *Service
  2716  	name       string
  2717  	variable   *Variable
  2718  	urlParams_ gensupport.URLParams
  2719  	ctx_       context.Context
  2720  	header_    http.Header
  2721  }
  2722  
  2723  // Update: Updates an existing variable with a new value.
  2724  //
  2725  //   - name: The name of the variable to update, in the format:
  2726  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/variables/[VARIABLE_NAME]`.
  2727  func (r *ProjectsConfigsVariablesService) Update(name string, variable *Variable) *ProjectsConfigsVariablesUpdateCall {
  2728  	c := &ProjectsConfigsVariablesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2729  	c.name = name
  2730  	c.variable = variable
  2731  	return c
  2732  }
  2733  
  2734  // Fields allows partial responses to be retrieved. See
  2735  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2736  // details.
  2737  func (c *ProjectsConfigsVariablesUpdateCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesUpdateCall {
  2738  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2739  	return c
  2740  }
  2741  
  2742  // Context sets the context to be used in this call's Do method.
  2743  func (c *ProjectsConfigsVariablesUpdateCall) Context(ctx context.Context) *ProjectsConfigsVariablesUpdateCall {
  2744  	c.ctx_ = ctx
  2745  	return c
  2746  }
  2747  
  2748  // Header returns a http.Header that can be modified by the caller to add
  2749  // headers to the request.
  2750  func (c *ProjectsConfigsVariablesUpdateCall) Header() http.Header {
  2751  	if c.header_ == nil {
  2752  		c.header_ = make(http.Header)
  2753  	}
  2754  	return c.header_
  2755  }
  2756  
  2757  func (c *ProjectsConfigsVariablesUpdateCall) doRequest(alt string) (*http.Response, error) {
  2758  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2759  	var body io.Reader = nil
  2760  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.variable)
  2761  	if err != nil {
  2762  		return nil, err
  2763  	}
  2764  	c.urlParams_.Set("alt", alt)
  2765  	c.urlParams_.Set("prettyPrint", "false")
  2766  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  2767  	urls += "?" + c.urlParams_.Encode()
  2768  	req, err := http.NewRequest("PUT", urls, body)
  2769  	if err != nil {
  2770  		return nil, err
  2771  	}
  2772  	req.Header = reqHeaders
  2773  	googleapi.Expand(req.URL, map[string]string{
  2774  		"name": c.name,
  2775  	})
  2776  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2777  }
  2778  
  2779  // Do executes the "runtimeconfig.projects.configs.variables.update" call.
  2780  // Any non-2xx status code is an error. Response headers are in either
  2781  // *Variable.ServerResponse.Header or (if a response was returned at all) in
  2782  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2783  // whether the returned error was because http.StatusNotModified was returned.
  2784  func (c *ProjectsConfigsVariablesUpdateCall) Do(opts ...googleapi.CallOption) (*Variable, error) {
  2785  	gensupport.SetOptions(c.urlParams_, opts...)
  2786  	res, err := c.doRequest("json")
  2787  	if res != nil && res.StatusCode == http.StatusNotModified {
  2788  		if res.Body != nil {
  2789  			res.Body.Close()
  2790  		}
  2791  		return nil, gensupport.WrapError(&googleapi.Error{
  2792  			Code:   res.StatusCode,
  2793  			Header: res.Header,
  2794  		})
  2795  	}
  2796  	if err != nil {
  2797  		return nil, err
  2798  	}
  2799  	defer googleapi.CloseBody(res)
  2800  	if err := googleapi.CheckResponse(res); err != nil {
  2801  		return nil, gensupport.WrapError(err)
  2802  	}
  2803  	ret := &Variable{
  2804  		ServerResponse: googleapi.ServerResponse{
  2805  			Header:         res.Header,
  2806  			HTTPStatusCode: res.StatusCode,
  2807  		},
  2808  	}
  2809  	target := &ret
  2810  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2811  		return nil, err
  2812  	}
  2813  	return ret, nil
  2814  }
  2815  
  2816  type ProjectsConfigsVariablesWatchCall struct {
  2817  	s                    *Service
  2818  	name                 string
  2819  	watchvariablerequest *WatchVariableRequest
  2820  	urlParams_           gensupport.URLParams
  2821  	ctx_                 context.Context
  2822  	header_              http.Header
  2823  }
  2824  
  2825  // Watch: Watches a specific variable and waits for a change in the variable's
  2826  // value. When there is a change, this method returns the new value or times
  2827  // out. If a variable is deleted while being watched, the `variableState` state
  2828  // is set to `DELETED` and the method returns the last known variable `value`.
  2829  // If you set the deadline for watching to a larger value than internal timeout
  2830  // (60 seconds), the current variable value is returned and the `variableState`
  2831  // will be `VARIABLE_STATE_UNSPECIFIED`. To learn more about creating a
  2832  // watcher, read the Watching a Variable for Changes
  2833  // (/deployment-manager/runtime-configurator/watching-a-variable)
  2834  // documentation.
  2835  //
  2836  //   - name: The name of the variable to watch, in the format:
  2837  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  2838  func (r *ProjectsConfigsVariablesService) Watch(name string, watchvariablerequest *WatchVariableRequest) *ProjectsConfigsVariablesWatchCall {
  2839  	c := &ProjectsConfigsVariablesWatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2840  	c.name = name
  2841  	c.watchvariablerequest = watchvariablerequest
  2842  	return c
  2843  }
  2844  
  2845  // Fields allows partial responses to be retrieved. See
  2846  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2847  // details.
  2848  func (c *ProjectsConfigsVariablesWatchCall) Fields(s ...googleapi.Field) *ProjectsConfigsVariablesWatchCall {
  2849  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2850  	return c
  2851  }
  2852  
  2853  // Context sets the context to be used in this call's Do method.
  2854  func (c *ProjectsConfigsVariablesWatchCall) Context(ctx context.Context) *ProjectsConfigsVariablesWatchCall {
  2855  	c.ctx_ = ctx
  2856  	return c
  2857  }
  2858  
  2859  // Header returns a http.Header that can be modified by the caller to add
  2860  // headers to the request.
  2861  func (c *ProjectsConfigsVariablesWatchCall) Header() http.Header {
  2862  	if c.header_ == nil {
  2863  		c.header_ = make(http.Header)
  2864  	}
  2865  	return c.header_
  2866  }
  2867  
  2868  func (c *ProjectsConfigsVariablesWatchCall) doRequest(alt string) (*http.Response, error) {
  2869  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2870  	var body io.Reader = nil
  2871  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.watchvariablerequest)
  2872  	if err != nil {
  2873  		return nil, err
  2874  	}
  2875  	c.urlParams_.Set("alt", alt)
  2876  	c.urlParams_.Set("prettyPrint", "false")
  2877  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}:watch")
  2878  	urls += "?" + c.urlParams_.Encode()
  2879  	req, err := http.NewRequest("POST", urls, body)
  2880  	if err != nil {
  2881  		return nil, err
  2882  	}
  2883  	req.Header = reqHeaders
  2884  	googleapi.Expand(req.URL, map[string]string{
  2885  		"name": c.name,
  2886  	})
  2887  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2888  }
  2889  
  2890  // Do executes the "runtimeconfig.projects.configs.variables.watch" call.
  2891  // Any non-2xx status code is an error. Response headers are in either
  2892  // *Variable.ServerResponse.Header or (if a response was returned at all) in
  2893  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2894  // whether the returned error was because http.StatusNotModified was returned.
  2895  func (c *ProjectsConfigsVariablesWatchCall) Do(opts ...googleapi.CallOption) (*Variable, error) {
  2896  	gensupport.SetOptions(c.urlParams_, opts...)
  2897  	res, err := c.doRequest("json")
  2898  	if res != nil && res.StatusCode == http.StatusNotModified {
  2899  		if res.Body != nil {
  2900  			res.Body.Close()
  2901  		}
  2902  		return nil, gensupport.WrapError(&googleapi.Error{
  2903  			Code:   res.StatusCode,
  2904  			Header: res.Header,
  2905  		})
  2906  	}
  2907  	if err != nil {
  2908  		return nil, err
  2909  	}
  2910  	defer googleapi.CloseBody(res)
  2911  	if err := googleapi.CheckResponse(res); err != nil {
  2912  		return nil, gensupport.WrapError(err)
  2913  	}
  2914  	ret := &Variable{
  2915  		ServerResponse: googleapi.ServerResponse{
  2916  			Header:         res.Header,
  2917  			HTTPStatusCode: res.StatusCode,
  2918  		},
  2919  	}
  2920  	target := &ret
  2921  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2922  		return nil, err
  2923  	}
  2924  	return ret, nil
  2925  }
  2926  
  2927  type ProjectsConfigsWaitersCreateCall struct {
  2928  	s          *Service
  2929  	parent     string
  2930  	waiter     *Waiter
  2931  	urlParams_ gensupport.URLParams
  2932  	ctx_       context.Context
  2933  	header_    http.Header
  2934  }
  2935  
  2936  // Create: Creates a Waiter resource. This operation returns a long-running
  2937  // Operation resource which can be polled for completion. However, a waiter
  2938  // with the given name will exist (and can be retrieved) prior to the operation
  2939  // completing. If the operation fails, the failed Waiter resource will still
  2940  // exist and must be deleted prior to subsequent creation attempts.
  2941  //
  2942  //   - parent: The path to the configuration that will own the waiter. The
  2943  //     configuration must exist beforehand; the path must be in the format:
  2944  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  2945  func (r *ProjectsConfigsWaitersService) Create(parent string, waiter *Waiter) *ProjectsConfigsWaitersCreateCall {
  2946  	c := &ProjectsConfigsWaitersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2947  	c.parent = parent
  2948  	c.waiter = waiter
  2949  	return c
  2950  }
  2951  
  2952  // RequestId sets the optional parameter "requestId": An optional but
  2953  // recommended unique `request_id`. If the server receives two `create()`
  2954  // requests with the same `request_id`, then the second request will be ignored
  2955  // and the first resource created and stored in the backend is returned. Empty
  2956  // `request_id` fields are ignored. It is responsibility of the client to
  2957  // ensure uniqueness of the `request_id` strings. `request_id` strings are
  2958  // limited to 64 characters.
  2959  func (c *ProjectsConfigsWaitersCreateCall) RequestId(requestId string) *ProjectsConfigsWaitersCreateCall {
  2960  	c.urlParams_.Set("requestId", requestId)
  2961  	return c
  2962  }
  2963  
  2964  // Fields allows partial responses to be retrieved. See
  2965  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2966  // details.
  2967  func (c *ProjectsConfigsWaitersCreateCall) Fields(s ...googleapi.Field) *ProjectsConfigsWaitersCreateCall {
  2968  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2969  	return c
  2970  }
  2971  
  2972  // Context sets the context to be used in this call's Do method.
  2973  func (c *ProjectsConfigsWaitersCreateCall) Context(ctx context.Context) *ProjectsConfigsWaitersCreateCall {
  2974  	c.ctx_ = ctx
  2975  	return c
  2976  }
  2977  
  2978  // Header returns a http.Header that can be modified by the caller to add
  2979  // headers to the request.
  2980  func (c *ProjectsConfigsWaitersCreateCall) Header() http.Header {
  2981  	if c.header_ == nil {
  2982  		c.header_ = make(http.Header)
  2983  	}
  2984  	return c.header_
  2985  }
  2986  
  2987  func (c *ProjectsConfigsWaitersCreateCall) doRequest(alt string) (*http.Response, error) {
  2988  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2989  	var body io.Reader = nil
  2990  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.waiter)
  2991  	if err != nil {
  2992  		return nil, err
  2993  	}
  2994  	c.urlParams_.Set("alt", alt)
  2995  	c.urlParams_.Set("prettyPrint", "false")
  2996  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/waiters")
  2997  	urls += "?" + c.urlParams_.Encode()
  2998  	req, err := http.NewRequest("POST", urls, body)
  2999  	if err != nil {
  3000  		return nil, err
  3001  	}
  3002  	req.Header = reqHeaders
  3003  	googleapi.Expand(req.URL, map[string]string{
  3004  		"parent": c.parent,
  3005  	})
  3006  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3007  }
  3008  
  3009  // Do executes the "runtimeconfig.projects.configs.waiters.create" call.
  3010  // Any non-2xx status code is an error. Response headers are in either
  3011  // *Operation.ServerResponse.Header or (if a response was returned at all) in
  3012  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  3013  // whether the returned error was because http.StatusNotModified was returned.
  3014  func (c *ProjectsConfigsWaitersCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
  3015  	gensupport.SetOptions(c.urlParams_, opts...)
  3016  	res, err := c.doRequest("json")
  3017  	if res != nil && res.StatusCode == http.StatusNotModified {
  3018  		if res.Body != nil {
  3019  			res.Body.Close()
  3020  		}
  3021  		return nil, gensupport.WrapError(&googleapi.Error{
  3022  			Code:   res.StatusCode,
  3023  			Header: res.Header,
  3024  		})
  3025  	}
  3026  	if err != nil {
  3027  		return nil, err
  3028  	}
  3029  	defer googleapi.CloseBody(res)
  3030  	if err := googleapi.CheckResponse(res); err != nil {
  3031  		return nil, gensupport.WrapError(err)
  3032  	}
  3033  	ret := &Operation{
  3034  		ServerResponse: googleapi.ServerResponse{
  3035  			Header:         res.Header,
  3036  			HTTPStatusCode: res.StatusCode,
  3037  		},
  3038  	}
  3039  	target := &ret
  3040  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3041  		return nil, err
  3042  	}
  3043  	return ret, nil
  3044  }
  3045  
  3046  type ProjectsConfigsWaitersDeleteCall struct {
  3047  	s          *Service
  3048  	name       string
  3049  	urlParams_ gensupport.URLParams
  3050  	ctx_       context.Context
  3051  	header_    http.Header
  3052  }
  3053  
  3054  // Delete: Deletes the waiter with the specified name.
  3055  //
  3056  //   - name: The Waiter resource to delete, in the format:
  3057  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]`.
  3058  func (r *ProjectsConfigsWaitersService) Delete(name string) *ProjectsConfigsWaitersDeleteCall {
  3059  	c := &ProjectsConfigsWaitersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3060  	c.name = name
  3061  	return c
  3062  }
  3063  
  3064  // Fields allows partial responses to be retrieved. See
  3065  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3066  // details.
  3067  func (c *ProjectsConfigsWaitersDeleteCall) Fields(s ...googleapi.Field) *ProjectsConfigsWaitersDeleteCall {
  3068  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3069  	return c
  3070  }
  3071  
  3072  // Context sets the context to be used in this call's Do method.
  3073  func (c *ProjectsConfigsWaitersDeleteCall) Context(ctx context.Context) *ProjectsConfigsWaitersDeleteCall {
  3074  	c.ctx_ = ctx
  3075  	return c
  3076  }
  3077  
  3078  // Header returns a http.Header that can be modified by the caller to add
  3079  // headers to the request.
  3080  func (c *ProjectsConfigsWaitersDeleteCall) Header() http.Header {
  3081  	if c.header_ == nil {
  3082  		c.header_ = make(http.Header)
  3083  	}
  3084  	return c.header_
  3085  }
  3086  
  3087  func (c *ProjectsConfigsWaitersDeleteCall) doRequest(alt string) (*http.Response, error) {
  3088  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3089  	var body io.Reader = nil
  3090  	c.urlParams_.Set("alt", alt)
  3091  	c.urlParams_.Set("prettyPrint", "false")
  3092  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  3093  	urls += "?" + c.urlParams_.Encode()
  3094  	req, err := http.NewRequest("DELETE", urls, body)
  3095  	if err != nil {
  3096  		return nil, err
  3097  	}
  3098  	req.Header = reqHeaders
  3099  	googleapi.Expand(req.URL, map[string]string{
  3100  		"name": c.name,
  3101  	})
  3102  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3103  }
  3104  
  3105  // Do executes the "runtimeconfig.projects.configs.waiters.delete" call.
  3106  // Any non-2xx status code is an error. Response headers are in either
  3107  // *Empty.ServerResponse.Header or (if a response was returned at all) in
  3108  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  3109  // whether the returned error was because http.StatusNotModified was returned.
  3110  func (c *ProjectsConfigsWaitersDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  3111  	gensupport.SetOptions(c.urlParams_, opts...)
  3112  	res, err := c.doRequest("json")
  3113  	if res != nil && res.StatusCode == http.StatusNotModified {
  3114  		if res.Body != nil {
  3115  			res.Body.Close()
  3116  		}
  3117  		return nil, gensupport.WrapError(&googleapi.Error{
  3118  			Code:   res.StatusCode,
  3119  			Header: res.Header,
  3120  		})
  3121  	}
  3122  	if err != nil {
  3123  		return nil, err
  3124  	}
  3125  	defer googleapi.CloseBody(res)
  3126  	if err := googleapi.CheckResponse(res); err != nil {
  3127  		return nil, gensupport.WrapError(err)
  3128  	}
  3129  	ret := &Empty{
  3130  		ServerResponse: googleapi.ServerResponse{
  3131  			Header:         res.Header,
  3132  			HTTPStatusCode: res.StatusCode,
  3133  		},
  3134  	}
  3135  	target := &ret
  3136  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3137  		return nil, err
  3138  	}
  3139  	return ret, nil
  3140  }
  3141  
  3142  type ProjectsConfigsWaitersGetCall struct {
  3143  	s            *Service
  3144  	name         string
  3145  	urlParams_   gensupport.URLParams
  3146  	ifNoneMatch_ string
  3147  	ctx_         context.Context
  3148  	header_      http.Header
  3149  }
  3150  
  3151  // Get: Gets information about a single waiter.
  3152  //
  3153  //   - name: The fully-qualified name of the Waiter resource object to retrieve,
  3154  //     in the format:
  3155  //     `projects/[PROJECT_ID]/configs/[CONFIG_NAME]/waiters/[WAITER_NAME]`.
  3156  func (r *ProjectsConfigsWaitersService) Get(name string) *ProjectsConfigsWaitersGetCall {
  3157  	c := &ProjectsConfigsWaitersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3158  	c.name = name
  3159  	return c
  3160  }
  3161  
  3162  // Fields allows partial responses to be retrieved. See
  3163  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3164  // details.
  3165  func (c *ProjectsConfigsWaitersGetCall) Fields(s ...googleapi.Field) *ProjectsConfigsWaitersGetCall {
  3166  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3167  	return c
  3168  }
  3169  
  3170  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  3171  // object's ETag matches the given value. This is useful for getting updates
  3172  // only after the object has changed since the last request.
  3173  func (c *ProjectsConfigsWaitersGetCall) IfNoneMatch(entityTag string) *ProjectsConfigsWaitersGetCall {
  3174  	c.ifNoneMatch_ = entityTag
  3175  	return c
  3176  }
  3177  
  3178  // Context sets the context to be used in this call's Do method.
  3179  func (c *ProjectsConfigsWaitersGetCall) Context(ctx context.Context) *ProjectsConfigsWaitersGetCall {
  3180  	c.ctx_ = ctx
  3181  	return c
  3182  }
  3183  
  3184  // Header returns a http.Header that can be modified by the caller to add
  3185  // headers to the request.
  3186  func (c *ProjectsConfigsWaitersGetCall) Header() http.Header {
  3187  	if c.header_ == nil {
  3188  		c.header_ = make(http.Header)
  3189  	}
  3190  	return c.header_
  3191  }
  3192  
  3193  func (c *ProjectsConfigsWaitersGetCall) doRequest(alt string) (*http.Response, error) {
  3194  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3195  	if c.ifNoneMatch_ != "" {
  3196  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  3197  	}
  3198  	var body io.Reader = nil
  3199  	c.urlParams_.Set("alt", alt)
  3200  	c.urlParams_.Set("prettyPrint", "false")
  3201  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+name}")
  3202  	urls += "?" + c.urlParams_.Encode()
  3203  	req, err := http.NewRequest("GET", urls, body)
  3204  	if err != nil {
  3205  		return nil, err
  3206  	}
  3207  	req.Header = reqHeaders
  3208  	googleapi.Expand(req.URL, map[string]string{
  3209  		"name": c.name,
  3210  	})
  3211  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3212  }
  3213  
  3214  // Do executes the "runtimeconfig.projects.configs.waiters.get" call.
  3215  // Any non-2xx status code is an error. Response headers are in either
  3216  // *Waiter.ServerResponse.Header or (if a response was returned at all) in
  3217  // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  3218  // whether the returned error was because http.StatusNotModified was returned.
  3219  func (c *ProjectsConfigsWaitersGetCall) Do(opts ...googleapi.CallOption) (*Waiter, error) {
  3220  	gensupport.SetOptions(c.urlParams_, opts...)
  3221  	res, err := c.doRequest("json")
  3222  	if res != nil && res.StatusCode == http.StatusNotModified {
  3223  		if res.Body != nil {
  3224  			res.Body.Close()
  3225  		}
  3226  		return nil, gensupport.WrapError(&googleapi.Error{
  3227  			Code:   res.StatusCode,
  3228  			Header: res.Header,
  3229  		})
  3230  	}
  3231  	if err != nil {
  3232  		return nil, err
  3233  	}
  3234  	defer googleapi.CloseBody(res)
  3235  	if err := googleapi.CheckResponse(res); err != nil {
  3236  		return nil, gensupport.WrapError(err)
  3237  	}
  3238  	ret := &Waiter{
  3239  		ServerResponse: googleapi.ServerResponse{
  3240  			Header:         res.Header,
  3241  			HTTPStatusCode: res.StatusCode,
  3242  		},
  3243  	}
  3244  	target := &ret
  3245  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3246  		return nil, err
  3247  	}
  3248  	return ret, nil
  3249  }
  3250  
  3251  type ProjectsConfigsWaitersListCall struct {
  3252  	s            *Service
  3253  	parent       string
  3254  	urlParams_   gensupport.URLParams
  3255  	ifNoneMatch_ string
  3256  	ctx_         context.Context
  3257  	header_      http.Header
  3258  }
  3259  
  3260  // List: List waiters within the given configuration.
  3261  //
  3262  //   - parent: The path to the configuration for which you want to get a list of
  3263  //     waiters. The configuration must exist beforehand; the path must be in the
  3264  //     format: `projects/[PROJECT_ID]/configs/[CONFIG_NAME]`.
  3265  func (r *ProjectsConfigsWaitersService) List(parent string) *ProjectsConfigsWaitersListCall {
  3266  	c := &ProjectsConfigsWaitersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3267  	c.parent = parent
  3268  	return c
  3269  }
  3270  
  3271  // PageSize sets the optional parameter "pageSize": Specifies the number of
  3272  // results to return per page. If there are fewer elements than the specified
  3273  // number, returns all elements.
  3274  func (c *ProjectsConfigsWaitersListCall) PageSize(pageSize int64) *ProjectsConfigsWaitersListCall {
  3275  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  3276  	return c
  3277  }
  3278  
  3279  // PageToken sets the optional parameter "pageToken": Specifies a page token to
  3280  // use. Set `pageToken` to a `nextPageToken` returned by a previous list
  3281  // request to get the next page of results.
  3282  func (c *ProjectsConfigsWaitersListCall) PageToken(pageToken string) *ProjectsConfigsWaitersListCall {
  3283  	c.urlParams_.Set("pageToken", pageToken)
  3284  	return c
  3285  }
  3286  
  3287  // Fields allows partial responses to be retrieved. See
  3288  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3289  // details.
  3290  func (c *ProjectsConfigsWaitersListCall) Fields(s ...googleapi.Field) *ProjectsConfigsWaitersListCall {
  3291  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3292  	return c
  3293  }
  3294  
  3295  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  3296  // object's ETag matches the given value. This is useful for getting updates
  3297  // only after the object has changed since the last request.
  3298  func (c *ProjectsConfigsWaitersListCall) IfNoneMatch(entityTag string) *ProjectsConfigsWaitersListCall {
  3299  	c.ifNoneMatch_ = entityTag
  3300  	return c
  3301  }
  3302  
  3303  // Context sets the context to be used in this call's Do method.
  3304  func (c *ProjectsConfigsWaitersListCall) Context(ctx context.Context) *ProjectsConfigsWaitersListCall {
  3305  	c.ctx_ = ctx
  3306  	return c
  3307  }
  3308  
  3309  // Header returns a http.Header that can be modified by the caller to add
  3310  // headers to the request.
  3311  func (c *ProjectsConfigsWaitersListCall) Header() http.Header {
  3312  	if c.header_ == nil {
  3313  		c.header_ = make(http.Header)
  3314  	}
  3315  	return c.header_
  3316  }
  3317  
  3318  func (c *ProjectsConfigsWaitersListCall) doRequest(alt string) (*http.Response, error) {
  3319  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3320  	if c.ifNoneMatch_ != "" {
  3321  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  3322  	}
  3323  	var body io.Reader = nil
  3324  	c.urlParams_.Set("alt", alt)
  3325  	c.urlParams_.Set("prettyPrint", "false")
  3326  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+parent}/waiters")
  3327  	urls += "?" + c.urlParams_.Encode()
  3328  	req, err := http.NewRequest("GET", urls, body)
  3329  	if err != nil {
  3330  		return nil, err
  3331  	}
  3332  	req.Header = reqHeaders
  3333  	googleapi.Expand(req.URL, map[string]string{
  3334  		"parent": c.parent,
  3335  	})
  3336  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3337  }
  3338  
  3339  // Do executes the "runtimeconfig.projects.configs.waiters.list" call.
  3340  // Any non-2xx status code is an error. Response headers are in either
  3341  // *ListWaitersResponse.ServerResponse.Header or (if a response was returned at
  3342  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3343  // check whether the returned error was because http.StatusNotModified was
  3344  // returned.
  3345  func (c *ProjectsConfigsWaitersListCall) Do(opts ...googleapi.CallOption) (*ListWaitersResponse, error) {
  3346  	gensupport.SetOptions(c.urlParams_, opts...)
  3347  	res, err := c.doRequest("json")
  3348  	if res != nil && res.StatusCode == http.StatusNotModified {
  3349  		if res.Body != nil {
  3350  			res.Body.Close()
  3351  		}
  3352  		return nil, gensupport.WrapError(&googleapi.Error{
  3353  			Code:   res.StatusCode,
  3354  			Header: res.Header,
  3355  		})
  3356  	}
  3357  	if err != nil {
  3358  		return nil, err
  3359  	}
  3360  	defer googleapi.CloseBody(res)
  3361  	if err := googleapi.CheckResponse(res); err != nil {
  3362  		return nil, gensupport.WrapError(err)
  3363  	}
  3364  	ret := &ListWaitersResponse{
  3365  		ServerResponse: googleapi.ServerResponse{
  3366  			Header:         res.Header,
  3367  			HTTPStatusCode: res.StatusCode,
  3368  		},
  3369  	}
  3370  	target := &ret
  3371  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3372  		return nil, err
  3373  	}
  3374  	return ret, nil
  3375  }
  3376  
  3377  // Pages invokes f for each page of results.
  3378  // A non-nil error returned from f will halt the iteration.
  3379  // The provided context supersedes any context provided to the Context method.
  3380  func (c *ProjectsConfigsWaitersListCall) Pages(ctx context.Context, f func(*ListWaitersResponse) error) error {
  3381  	c.ctx_ = ctx
  3382  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  3383  	for {
  3384  		x, err := c.Do()
  3385  		if err != nil {
  3386  			return err
  3387  		}
  3388  		if err := f(x); err != nil {
  3389  			return err
  3390  		}
  3391  		if x.NextPageToken == "" {
  3392  			return nil
  3393  		}
  3394  		c.PageToken(x.NextPageToken)
  3395  	}
  3396  }
  3397  
  3398  type ProjectsConfigsWaitersTestIamPermissionsCall struct {
  3399  	s                         *Service
  3400  	resource                  string
  3401  	testiampermissionsrequest *TestIamPermissionsRequest
  3402  	urlParams_                gensupport.URLParams
  3403  	ctx_                      context.Context
  3404  	header_                   http.Header
  3405  }
  3406  
  3407  // TestIamPermissions: Returns permissions that a caller has on the specified
  3408  // resource. If the resource does not exist, this will return an empty set of
  3409  // permissions, not a `NOT_FOUND` error. Note: This operation is designed to be
  3410  // used for building permission-aware UIs and command-line tools, not for
  3411  // authorization checking. This operation may "fail open" without warning.
  3412  //
  3413  //   - resource: REQUIRED: The resource for which the policy detail is being
  3414  //     requested. See Resource names
  3415  //     (https://cloud.google.com/apis/design/resource_names) for the appropriate
  3416  //     value for this field.
  3417  func (r *ProjectsConfigsWaitersService) TestIamPermissions(resource string, testiampermissionsrequest *TestIamPermissionsRequest) *ProjectsConfigsWaitersTestIamPermissionsCall {
  3418  	c := &ProjectsConfigsWaitersTestIamPermissionsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3419  	c.resource = resource
  3420  	c.testiampermissionsrequest = testiampermissionsrequest
  3421  	return c
  3422  }
  3423  
  3424  // Fields allows partial responses to be retrieved. See
  3425  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3426  // details.
  3427  func (c *ProjectsConfigsWaitersTestIamPermissionsCall) Fields(s ...googleapi.Field) *ProjectsConfigsWaitersTestIamPermissionsCall {
  3428  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3429  	return c
  3430  }
  3431  
  3432  // Context sets the context to be used in this call's Do method.
  3433  func (c *ProjectsConfigsWaitersTestIamPermissionsCall) Context(ctx context.Context) *ProjectsConfigsWaitersTestIamPermissionsCall {
  3434  	c.ctx_ = ctx
  3435  	return c
  3436  }
  3437  
  3438  // Header returns a http.Header that can be modified by the caller to add
  3439  // headers to the request.
  3440  func (c *ProjectsConfigsWaitersTestIamPermissionsCall) Header() http.Header {
  3441  	if c.header_ == nil {
  3442  		c.header_ = make(http.Header)
  3443  	}
  3444  	return c.header_
  3445  }
  3446  
  3447  func (c *ProjectsConfigsWaitersTestIamPermissionsCall) doRequest(alt string) (*http.Response, error) {
  3448  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3449  	var body io.Reader = nil
  3450  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.testiampermissionsrequest)
  3451  	if err != nil {
  3452  		return nil, err
  3453  	}
  3454  	c.urlParams_.Set("alt", alt)
  3455  	c.urlParams_.Set("prettyPrint", "false")
  3456  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta1/{+resource}:testIamPermissions")
  3457  	urls += "?" + c.urlParams_.Encode()
  3458  	req, err := http.NewRequest("POST", urls, body)
  3459  	if err != nil {
  3460  		return nil, err
  3461  	}
  3462  	req.Header = reqHeaders
  3463  	googleapi.Expand(req.URL, map[string]string{
  3464  		"resource": c.resource,
  3465  	})
  3466  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3467  }
  3468  
  3469  // Do executes the "runtimeconfig.projects.configs.waiters.testIamPermissions" call.
  3470  // Any non-2xx status code is an error. Response headers are in either
  3471  // *TestIamPermissionsResponse.ServerResponse.Header or (if a response was
  3472  // returned at all) in error.(*googleapi.Error).Header. Use
  3473  // googleapi.IsNotModified to check whether the returned error was because
  3474  // http.StatusNotModified was returned.
  3475  func (c *ProjectsConfigsWaitersTestIamPermissionsCall) Do(opts ...googleapi.CallOption) (*TestIamPermissionsResponse, error) {
  3476  	gensupport.SetOptions(c.urlParams_, opts...)
  3477  	res, err := c.doRequest("json")
  3478  	if res != nil && res.StatusCode == http.StatusNotModified {
  3479  		if res.Body != nil {
  3480  			res.Body.Close()
  3481  		}
  3482  		return nil, gensupport.WrapError(&googleapi.Error{
  3483  			Code:   res.StatusCode,
  3484  			Header: res.Header,
  3485  		})
  3486  	}
  3487  	if err != nil {
  3488  		return nil, err
  3489  	}
  3490  	defer googleapi.CloseBody(res)
  3491  	if err := googleapi.CheckResponse(res); err != nil {
  3492  		return nil, gensupport.WrapError(err)
  3493  	}
  3494  	ret := &TestIamPermissionsResponse{
  3495  		ServerResponse: googleapi.ServerResponse{
  3496  			Header:         res.Header,
  3497  			HTTPStatusCode: res.StatusCode,
  3498  		},
  3499  	}
  3500  	target := &ret
  3501  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3502  		return nil, err
  3503  	}
  3504  	return ret, nil
  3505  }
  3506  

View as plain text