▽

Source file src/google.golang.org/api/sasportal/v1alpha1/sasportal-gen.go

Documentation: google.golang.org/api/sasportal/v1alpha1

     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 sasportal provides access to the SAS Portal API.
     8  //
     9  // For product documentation, see: https://developers.google.com/spectrum-access-system/
    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/sasportal/v1alpha1"
    27  //	...
    28  //	ctx := context.Background()
    29  //	sasportalService, err := sasportal.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  //	sasportalService, err := sasportal.NewService(ctx, option.WithScopes(sasportal.SasportalScope))
    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  //	sasportalService, err := sasportal.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  //	sasportalService, err := sasportal.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
    54  //
    55  // See [google.golang.org/api/option.ClientOption] for details on options.
    56  package sasportal // import "google.golang.org/api/sasportal/v1alpha1"
    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 = "sasportal:v1alpha1"
    95  const apiName = "sasportal"
    96  const apiVersion = "v1alpha1"
    97  const basePath = "https://sasportal.googleapis.com/"
    98  const basePathTemplate = "https://sasportal.UNIVERSE_DOMAIN/"
    99  const mtlsBasePath = "https://sasportal.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  	// Read, create, update, and delete your SAS Portal data.
   108  	SasportalScope = "https://www.googleapis.com/auth/sasportal"
   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/sasportal",
   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.Customers = NewCustomersService(s)
   148  	s.Deployments = NewDeploymentsService(s)
   149  	s.Installer = NewInstallerService(s)
   150  	s.Nodes = NewNodesService(s)
   151  	s.Policies = NewPoliciesService(s)
   152  	return s, nil
   153  }
   154  
   155  type Service struct {
   156  	client    *http.Client
   157  	BasePath  string // API endpoint base URL
   158  	UserAgent string // optional additional User-Agent fragment
   159  
   160  	Customers *CustomersService
   161  
   162  	Deployments *DeploymentsService
   163  
   164  	Installer *InstallerService
   165  
   166  	Nodes *NodesService
   167  
   168  	Policies *PoliciesService
   169  }
   170  
   171  func (s *Service) userAgent() string {
   172  	if s.UserAgent == "" {
   173  		return googleapi.UserAgent
   174  	}
   175  	return googleapi.UserAgent + " " + s.UserAgent
   176  }
   177  
   178  func NewCustomersService(s *Service) *CustomersService {
   179  	rs := &CustomersService{s: s}
   180  	rs.Deployments = NewCustomersDeploymentsService(s)
   181  	rs.Devices = NewCustomersDevicesService(s)
   182  	rs.Nodes = NewCustomersNodesService(s)
   183  	return rs
   184  }
   185  
   186  type CustomersService struct {
   187  	s *Service
   188  
   189  	Deployments *CustomersDeploymentsService
   190  
   191  	Devices *CustomersDevicesService
   192  
   193  	Nodes *CustomersNodesService
   194  }
   195  
   196  func NewCustomersDeploymentsService(s *Service) *CustomersDeploymentsService {
   197  	rs := &CustomersDeploymentsService{s: s}
   198  	rs.Devices = NewCustomersDeploymentsDevicesService(s)
   199  	return rs
   200  }
   201  
   202  type CustomersDeploymentsService struct {
   203  	s *Service
   204  
   205  	Devices *CustomersDeploymentsDevicesService
   206  }
   207  
   208  func NewCustomersDeploymentsDevicesService(s *Service) *CustomersDeploymentsDevicesService {
   209  	rs := &CustomersDeploymentsDevicesService{s: s}
   210  	return rs
   211  }
   212  
   213  type CustomersDeploymentsDevicesService struct {
   214  	s *Service
   215  }
   216  
   217  func NewCustomersDevicesService(s *Service) *CustomersDevicesService {
   218  	rs := &CustomersDevicesService{s: s}
   219  	return rs
   220  }
   221  
   222  type CustomersDevicesService struct {
   223  	s *Service
   224  }
   225  
   226  func NewCustomersNodesService(s *Service) *CustomersNodesService {
   227  	rs := &CustomersNodesService{s: s}
   228  	rs.Deployments = NewCustomersNodesDeploymentsService(s)
   229  	rs.Devices = NewCustomersNodesDevicesService(s)
   230  	rs.Nodes = NewCustomersNodesNodesService(s)
   231  	return rs
   232  }
   233  
   234  type CustomersNodesService struct {
   235  	s *Service
   236  
   237  	Deployments *CustomersNodesDeploymentsService
   238  
   239  	Devices *CustomersNodesDevicesService
   240  
   241  	Nodes *CustomersNodesNodesService
   242  }
   243  
   244  func NewCustomersNodesDeploymentsService(s *Service) *CustomersNodesDeploymentsService {
   245  	rs := &CustomersNodesDeploymentsService{s: s}
   246  	return rs
   247  }
   248  
   249  type CustomersNodesDeploymentsService struct {
   250  	s *Service
   251  }
   252  
   253  func NewCustomersNodesDevicesService(s *Service) *CustomersNodesDevicesService {
   254  	rs := &CustomersNodesDevicesService{s: s}
   255  	return rs
   256  }
   257  
   258  type CustomersNodesDevicesService struct {
   259  	s *Service
   260  }
   261  
   262  func NewCustomersNodesNodesService(s *Service) *CustomersNodesNodesService {
   263  	rs := &CustomersNodesNodesService{s: s}
   264  	return rs
   265  }
   266  
   267  type CustomersNodesNodesService struct {
   268  	s *Service
   269  }
   270  
   271  func NewDeploymentsService(s *Service) *DeploymentsService {
   272  	rs := &DeploymentsService{s: s}
   273  	rs.Devices = NewDeploymentsDevicesService(s)
   274  	return rs
   275  }
   276  
   277  type DeploymentsService struct {
   278  	s *Service
   279  
   280  	Devices *DeploymentsDevicesService
   281  }
   282  
   283  func NewDeploymentsDevicesService(s *Service) *DeploymentsDevicesService {
   284  	rs := &DeploymentsDevicesService{s: s}
   285  	return rs
   286  }
   287  
   288  type DeploymentsDevicesService struct {
   289  	s *Service
   290  }
   291  
   292  func NewInstallerService(s *Service) *InstallerService {
   293  	rs := &InstallerService{s: s}
   294  	return rs
   295  }
   296  
   297  type InstallerService struct {
   298  	s *Service
   299  }
   300  
   301  func NewNodesService(s *Service) *NodesService {
   302  	rs := &NodesService{s: s}
   303  	rs.Deployments = NewNodesDeploymentsService(s)
   304  	rs.Devices = NewNodesDevicesService(s)
   305  	rs.Nodes = NewNodesNodesService(s)
   306  	return rs
   307  }
   308  
   309  type NodesService struct {
   310  	s *Service
   311  
   312  	Deployments *NodesDeploymentsService
   313  
   314  	Devices *NodesDevicesService
   315  
   316  	Nodes *NodesNodesService
   317  }
   318  
   319  func NewNodesDeploymentsService(s *Service) *NodesDeploymentsService {
   320  	rs := &NodesDeploymentsService{s: s}
   321  	rs.Devices = NewNodesDeploymentsDevicesService(s)
   322  	return rs
   323  }
   324  
   325  type NodesDeploymentsService struct {
   326  	s *Service
   327  
   328  	Devices *NodesDeploymentsDevicesService
   329  }
   330  
   331  func NewNodesDeploymentsDevicesService(s *Service) *NodesDeploymentsDevicesService {
   332  	rs := &NodesDeploymentsDevicesService{s: s}
   333  	return rs
   334  }
   335  
   336  type NodesDeploymentsDevicesService struct {
   337  	s *Service
   338  }
   339  
   340  func NewNodesDevicesService(s *Service) *NodesDevicesService {
   341  	rs := &NodesDevicesService{s: s}
   342  	return rs
   343  }
   344  
   345  type NodesDevicesService struct {
   346  	s *Service
   347  }
   348  
   349  func NewNodesNodesService(s *Service) *NodesNodesService {
   350  	rs := &NodesNodesService{s: s}
   351  	rs.Deployments = NewNodesNodesDeploymentsService(s)
   352  	rs.Devices = NewNodesNodesDevicesService(s)
   353  	rs.Nodes = NewNodesNodesNodesService(s)
   354  	return rs
   355  }
   356  
   357  type NodesNodesService struct {
   358  	s *Service
   359  
   360  	Deployments *NodesNodesDeploymentsService
   361  
   362  	Devices *NodesNodesDevicesService
   363  
   364  	Nodes *NodesNodesNodesService
   365  }
   366  
   367  func NewNodesNodesDeploymentsService(s *Service) *NodesNodesDeploymentsService {
   368  	rs := &NodesNodesDeploymentsService{s: s}
   369  	return rs
   370  }
   371  
   372  type NodesNodesDeploymentsService struct {
   373  	s *Service
   374  }
   375  
   376  func NewNodesNodesDevicesService(s *Service) *NodesNodesDevicesService {
   377  	rs := &NodesNodesDevicesService{s: s}
   378  	return rs
   379  }
   380  
   381  type NodesNodesDevicesService struct {
   382  	s *Service
   383  }
   384  
   385  func NewNodesNodesNodesService(s *Service) *NodesNodesNodesService {
   386  	rs := &NodesNodesNodesService{s: s}
   387  	return rs
   388  }
   389  
   390  type NodesNodesNodesService struct {
   391  	s *Service
   392  }
   393  
   394  func NewPoliciesService(s *Service) *PoliciesService {
   395  	rs := &PoliciesService{s: s}
   396  	return rs
   397  }
   398  
   399  type PoliciesService struct {
   400  	s *Service
   401  }
   402  
   403  // SasPortalAssignment: Associates `members` with a `role`.
   404  type SasPortalAssignment struct {
   405  	// Members: The identities the role is assigned to. It can have the following
   406  	// values: * `{user_email}`: An email address that represents a specific Google
   407  	// account. For example: `alice@gmail.com`. * `{group_email}`: An email address
   408  	// that represents a Google group. For example, `viewers@gmail.com`.
   409  	Members []string `json:"members,omitempty"`
   410  	// Role: Required. Role that is assigned to `members`.
   411  	Role string `json:"role,omitempty"`
   412  	// ForceSendFields is a list of field names (e.g. "Members") to unconditionally
   413  	// include in API requests. By default, fields with empty or default values are
   414  	// omitted from API requests. See
   415  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   416  	// details.
   417  	ForceSendFields []string `json:"-"`
   418  	// NullFields is a list of field names (e.g. "Members") to include in API
   419  	// requests with the JSON null value. By default, fields with empty values are
   420  	// omitted from API requests. See
   421  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   422  	NullFields []string `json:"-"`
   423  }
   424  
   425  func (s *SasPortalAssignment) MarshalJSON() ([]byte, error) {
   426  	type NoMethod SasPortalAssignment
   427  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   428  }
   429  
   430  // SasPortalChannelWithScore: The channel with score.
   431  type SasPortalChannelWithScore struct {
   432  	// FrequencyRange: The frequency range of the channel.
   433  	FrequencyRange *SasPortalFrequencyRange `json:"frequencyRange,omitempty"`
   434  	// Score: The channel score, normalized to be in the range [0,100].
   435  	Score float64 `json:"score,omitempty"`
   436  	// ForceSendFields is a list of field names (e.g. "FrequencyRange") to
   437  	// unconditionally include in API requests. By default, fields with empty or
   438  	// default values are omitted from API requests. See
   439  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   440  	// details.
   441  	ForceSendFields []string `json:"-"`
   442  	// NullFields is a list of field names (e.g. "FrequencyRange") to include in
   443  	// API requests with the JSON null value. By default, fields with empty values
   444  	// are omitted from API requests. See
   445  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   446  	NullFields []string `json:"-"`
   447  }
   448  
   449  func (s *SasPortalChannelWithScore) MarshalJSON() ([]byte, error) {
   450  	type NoMethod SasPortalChannelWithScore
   451  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   452  }
   453  
   454  func (s *SasPortalChannelWithScore) UnmarshalJSON(data []byte) error {
   455  	type NoMethod SasPortalChannelWithScore
   456  	var s1 struct {
   457  		Score gensupport.JSONFloat64 `json:"score"`
   458  		*NoMethod
   459  	}
   460  	s1.NoMethod = (*NoMethod)(s)
   461  	if err := json.Unmarshal(data, &s1); err != nil {
   462  		return err
   463  	}
   464  	s.Score = float64(s1.Score)
   465  	return nil
   466  }
   467  
   468  // SasPortalCreateSignedDeviceRequest: Request for CreateSignedDevice.
   469  type SasPortalCreateSignedDeviceRequest struct {
   470  	// EncodedDevice: Required. JSON Web Token signed using a CPI private key.
   471  	// Payload must be the JSON encoding of the device. The user_id field must be
   472  	// set.
   473  	EncodedDevice string `json:"encodedDevice,omitempty"`
   474  	// InstallerId: Required. Unique installer id (CPI ID) from the Certified
   475  	// Professional Installers database.
   476  	InstallerId string `json:"installerId,omitempty"`
   477  	// ForceSendFields is a list of field names (e.g. "EncodedDevice") to
   478  	// unconditionally include in API requests. By default, fields with empty or
   479  	// default values are omitted from API requests. See
   480  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   481  	// details.
   482  	ForceSendFields []string `json:"-"`
   483  	// NullFields is a list of field names (e.g. "EncodedDevice") to include in API
   484  	// requests with the JSON null value. By default, fields with empty values are
   485  	// omitted from API requests. See
   486  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   487  	NullFields []string `json:"-"`
   488  }
   489  
   490  func (s *SasPortalCreateSignedDeviceRequest) MarshalJSON() ([]byte, error) {
   491  	type NoMethod SasPortalCreateSignedDeviceRequest
   492  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   493  }
   494  
   495  // SasPortalCustomer: Entity representing a SAS customer.
   496  type SasPortalCustomer struct {
   497  	// DisplayName: Required. Name of the organization that the customer entity
   498  	// represents.
   499  	DisplayName string `json:"displayName,omitempty"`
   500  	// Name: Output only. Resource name of the customer.
   501  	Name string `json:"name,omitempty"`
   502  	// SasUserIds: User IDs used by the devices belonging to this customer.
   503  	SasUserIds []string `json:"sasUserIds,omitempty"`
   504  
   505  	// ServerResponse contains the HTTP response code and headers from the server.
   506  	googleapi.ServerResponse `json:"-"`
   507  	// ForceSendFields is a list of field names (e.g. "DisplayName") to
   508  	// unconditionally include in API requests. By default, fields with empty or
   509  	// default values are omitted from API requests. See
   510  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   511  	// details.
   512  	ForceSendFields []string `json:"-"`
   513  	// NullFields is a list of field names (e.g. "DisplayName") to include in API
   514  	// requests with the JSON null value. By default, fields with empty values are
   515  	// omitted from API requests. See
   516  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   517  	NullFields []string `json:"-"`
   518  }
   519  
   520  func (s *SasPortalCustomer) MarshalJSON() ([]byte, error) {
   521  	type NoMethod SasPortalCustomer
   522  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   523  }
   524  
   525  // SasPortalDeployment: The Deployment.
   526  type SasPortalDeployment struct {
   527  	// DisplayName: The deployment's display name.
   528  	DisplayName string `json:"displayName,omitempty"`
   529  	// Frns: Output only. The FCC Registration Numbers (FRNs) copied from its
   530  	// direct parent.
   531  	Frns []string `json:"frns,omitempty"`
   532  	// Name: Output only. Resource name.
   533  	Name string `json:"name,omitempty"`
   534  	// SasUserIds: User ID used by the devices belonging to this deployment. Each
   535  	// deployment should be associated with one unique user ID.
   536  	SasUserIds []string `json:"sasUserIds,omitempty"`
   537  
   538  	// ServerResponse contains the HTTP response code and headers from the server.
   539  	googleapi.ServerResponse `json:"-"`
   540  	// ForceSendFields is a list of field names (e.g. "DisplayName") to
   541  	// unconditionally include in API requests. By default, fields with empty or
   542  	// default values are omitted from API requests. See
   543  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   544  	// details.
   545  	ForceSendFields []string `json:"-"`
   546  	// NullFields is a list of field names (e.g. "DisplayName") to include in API
   547  	// requests with the JSON null value. By default, fields with empty values are
   548  	// omitted from API requests. See
   549  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   550  	NullFields []string `json:"-"`
   551  }
   552  
   553  func (s *SasPortalDeployment) MarshalJSON() ([]byte, error) {
   554  	type NoMethod SasPortalDeployment
   555  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   556  }
   557  
   558  // SasPortalDeploymentAssociation: Association between a gcp project and a SAS
   559  // user id.
   560  type SasPortalDeploymentAssociation struct {
   561  	// GcpProjectId: GCP project id of the associated project.
   562  	GcpProjectId string `json:"gcpProjectId,omitempty"`
   563  	// UserId: User id of the deployment.
   564  	UserId string `json:"userId,omitempty"`
   565  	// ForceSendFields is a list of field names (e.g. "GcpProjectId") to
   566  	// unconditionally include in API requests. By default, fields with empty or
   567  	// default values are omitted from API requests. See
   568  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   569  	// details.
   570  	ForceSendFields []string `json:"-"`
   571  	// NullFields is a list of field names (e.g. "GcpProjectId") to include in API
   572  	// requests with the JSON null value. By default, fields with empty values are
   573  	// omitted from API requests. See
   574  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   575  	NullFields []string `json:"-"`
   576  }
   577  
   578  func (s *SasPortalDeploymentAssociation) MarshalJSON() ([]byte, error) {
   579  	type NoMethod SasPortalDeploymentAssociation
   580  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   581  }
   582  
   583  type SasPortalDevice struct {
   584  	// ActiveConfig: Output only. Current configuration of the device as registered
   585  	// to the SAS.
   586  	ActiveConfig *SasPortalDeviceConfig `json:"activeConfig,omitempty"`
   587  	// CurrentChannels: Output only. Current channels with scores.
   588  	CurrentChannels []*SasPortalChannelWithScore `json:"currentChannels,omitempty"`
   589  	// DeviceMetadata: Device parameters that can be overridden by both SAS Portal
   590  	// and SAS registration requests.
   591  	DeviceMetadata *SasPortalDeviceMetadata `json:"deviceMetadata,omitempty"`
   592  	// DisplayName: Device display name.
   593  	DisplayName string `json:"displayName,omitempty"`
   594  	// FccId: The FCC identifier of the device. Refer to
   595  	// https://www.fcc.gov/oet/ea/fccid for FccID format. Accept underscores and
   596  	// periods because some test-SAS customers use them.
   597  	FccId string `json:"fccId,omitempty"`
   598  	// GrantRangeAllowlists: Only ranges that are within the allowlists are
   599  	// available for new grants.
   600  	GrantRangeAllowlists []*SasPortalFrequencyRange `json:"grantRangeAllowlists,omitempty"`
   601  	// Grants: Output only. Grants held by the device.
   602  	Grants []*SasPortalDeviceGrant `json:"grants,omitempty"`
   603  	// Name: Output only. The resource path name.
   604  	Name string `json:"name,omitempty"`
   605  	// PreloadedConfig: Configuration of the device, as specified via SAS Portal
   606  	// API.
   607  	PreloadedConfig *SasPortalDeviceConfig `json:"preloadedConfig,omitempty"`
   608  	// SerialNumber: A serial number assigned to the device by the device
   609  	// manufacturer.
   610  	SerialNumber string `json:"serialNumber,omitempty"`
   611  	// State: Output only. Device state.
   612  	//
   613  	// Possible values:
   614  	//   "DEVICE_STATE_UNSPECIFIED" - Unspecified state.
   615  	//   "RESERVED" - Device created in the SAS Portal, however, not yet registered
   616  	// with SAS.
   617  	//   "REGISTERED" - Device registered with SAS.
   618  	//   "DEREGISTERED" - Device de-registered with SAS.
   619  	State string `json:"state,omitempty"`
   620  
   621  	// ServerResponse contains the HTTP response code and headers from the server.
   622  	googleapi.ServerResponse `json:"-"`
   623  	// ForceSendFields is a list of field names (e.g. "ActiveConfig") to
   624  	// unconditionally include in API requests. By default, fields with empty or
   625  	// default values are omitted from API requests. See
   626  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   627  	// details.
   628  	ForceSendFields []string `json:"-"`
   629  	// NullFields is a list of field names (e.g. "ActiveConfig") to include in API
   630  	// requests with the JSON null value. By default, fields with empty values are
   631  	// omitted from API requests. See
   632  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   633  	NullFields []string `json:"-"`
   634  }
   635  
   636  func (s *SasPortalDevice) MarshalJSON() ([]byte, error) {
   637  	type NoMethod SasPortalDevice
   638  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   639  }
   640  
   641  // SasPortalDeviceAirInterface: Information about the device's air interface.
   642  type SasPortalDeviceAirInterface struct {
   643  	// RadioTechnology: Conditional. This field specifies the radio access
   644  	// technology that is used for the CBSD.
   645  	//
   646  	// Possible values:
   647  	//   "RADIO_TECHNOLOGY_UNSPECIFIED"
   648  	//   "E_UTRA"
   649  	//   "CAMBIUM_NETWORKS"
   650  	//   "FOUR_G_BBW_SAA_1"
   651  	//   "NR"
   652  	//   "DOODLE_CBRS"
   653  	//   "CW"
   654  	//   "REDLINE"
   655  	//   "TARANA_WIRELESS"
   656  	RadioTechnology string `json:"radioTechnology,omitempty"`
   657  	// SupportedSpec: Optional. This field is related to the `radioTechnology` and
   658  	// provides the air interface specification that the CBSD is compliant with at
   659  	// the time of registration.
   660  	SupportedSpec string `json:"supportedSpec,omitempty"`
   661  	// ForceSendFields is a list of field names (e.g. "RadioTechnology") to
   662  	// unconditionally include in API requests. By default, fields with empty or
   663  	// default values are omitted from API requests. See
   664  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   665  	// details.
   666  	ForceSendFields []string `json:"-"`
   667  	// NullFields is a list of field names (e.g. "RadioTechnology") to include in
   668  	// API requests with the JSON null value. By default, fields with empty values
   669  	// are omitted from API requests. See
   670  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   671  	NullFields []string `json:"-"`
   672  }
   673  
   674  func (s *SasPortalDeviceAirInterface) MarshalJSON() ([]byte, error) {
   675  	type NoMethod SasPortalDeviceAirInterface
   676  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   677  }
   678  
   679  // SasPortalDeviceConfig: Information about the device configuration.
   680  type SasPortalDeviceConfig struct {
   681  	// AirInterface: Information about this device's air interface.
   682  	AirInterface *SasPortalDeviceAirInterface `json:"airInterface,omitempty"`
   683  	// CallSign: The call sign of the device operator.
   684  	CallSign string `json:"callSign,omitempty"`
   685  	// Category: FCC category of the device.
   686  	//
   687  	// Possible values:
   688  	//   "DEVICE_CATEGORY_UNSPECIFIED" - Unspecified device category.
   689  	//   "DEVICE_CATEGORY_A" - Category A.
   690  	//   "DEVICE_CATEGORY_B" - Category B.
   691  	Category string `json:"category,omitempty"`
   692  	// InstallationParams: Installation parameters for the device.
   693  	InstallationParams *SasPortalInstallationParams `json:"installationParams,omitempty"`
   694  	// IsSigned: Output only. Whether the configuration has been signed by a CPI.
   695  	IsSigned bool `json:"isSigned,omitempty"`
   696  	// MeasurementCapabilities: Measurement reporting capabilities of the device.
   697  	//
   698  	// Possible values:
   699  	//   "MEASUREMENT_CAPABILITY_UNSPECIFIED"
   700  	//   "MEASUREMENT_CAPABILITY_RECEIVED_POWER_WITH_GRANT"
   701  	//   "MEASUREMENT_CAPABILITY_RECEIVED_POWER_WITHOUT_GRANT"
   702  	MeasurementCapabilities []string `json:"measurementCapabilities,omitempty"`
   703  	// Model: Information about this device model.
   704  	Model *SasPortalDeviceModel `json:"model,omitempty"`
   705  	// State: State of the configuration.
   706  	//
   707  	// Possible values:
   708  	//   "DEVICE_CONFIG_STATE_UNSPECIFIED"
   709  	//   "DRAFT"
   710  	//   "FINAL"
   711  	State string `json:"state,omitempty"`
   712  	// UpdateTime: Output only. The last time the device configuration was edited.
   713  	UpdateTime string `json:"updateTime,omitempty"`
   714  	// UserId: The identifier of a device user.
   715  	UserId string `json:"userId,omitempty"`
   716  	// ForceSendFields is a list of field names (e.g. "AirInterface") to
   717  	// unconditionally include in API requests. By default, fields with empty or
   718  	// default values are omitted from API requests. See
   719  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   720  	// details.
   721  	ForceSendFields []string `json:"-"`
   722  	// NullFields is a list of field names (e.g. "AirInterface") to include in API
   723  	// requests with the JSON null value. By default, fields with empty values are
   724  	// omitted from API requests. See
   725  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   726  	NullFields []string `json:"-"`
   727  }
   728  
   729  func (s *SasPortalDeviceConfig) MarshalJSON() ([]byte, error) {
   730  	type NoMethod SasPortalDeviceConfig
   731  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   732  }
   733  
   734  // SasPortalDeviceGrant: Device grant. It is an authorization provided by the
   735  // Spectrum Access System to a device to transmit using specified operating
   736  // parameters after a successful heartbeat by the device.
   737  type SasPortalDeviceGrant struct {
   738  	// ChannelType: Type of channel used.
   739  	//
   740  	// Possible values:
   741  	//   "CHANNEL_TYPE_UNSPECIFIED"
   742  	//   "CHANNEL_TYPE_GAA"
   743  	//   "CHANNEL_TYPE_PAL"
   744  	ChannelType string `json:"channelType,omitempty"`
   745  	// ExpireTime: The expiration time of the grant.
   746  	ExpireTime string `json:"expireTime,omitempty"`
   747  	// FrequencyRange: The transmission frequency range.
   748  	FrequencyRange *SasPortalFrequencyRange `json:"frequencyRange,omitempty"`
   749  	// GrantId: Grant Id.
   750  	GrantId string `json:"grantId,omitempty"`
   751  	// LastHeartbeatTransmitExpireTime: The transmit expiration time of the last
   752  	// heartbeat.
   753  	LastHeartbeatTransmitExpireTime string `json:"lastHeartbeatTransmitExpireTime,omitempty"`
   754  	// MaxEirp: Maximum Equivalent Isotropically Radiated Power (EIRP) permitted by
   755  	// the grant. The maximum EIRP is in units of dBm/MHz. The value of `maxEirp`
   756  	// represents the average (RMS) EIRP that would be measured by the procedure
   757  	// defined in FCC part 96.41(e)(3).
   758  	MaxEirp float64 `json:"maxEirp,omitempty"`
   759  	// MoveList: The DPA move lists on which this grant appears.
   760  	MoveList []*SasPortalDpaMoveList `json:"moveList,omitempty"`
   761  	// State: State of the grant.
   762  	//
   763  	// Possible values:
   764  	//   "GRANT_STATE_UNSPECIFIED"
   765  	//   "GRANT_STATE_GRANTED" - The grant has been granted but the device is not
   766  	// heartbeating on it.
   767  	//   "GRANT_STATE_TERMINATED" - The grant has been terminated by the SAS.
   768  	//   "GRANT_STATE_SUSPENDED" - The grant has been suspended by the SAS.
   769  	//   "GRANT_STATE_AUTHORIZED" - The device is currently transmitting.
   770  	//   "GRANT_STATE_EXPIRED" - The grant has expired.
   771  	State string `json:"state,omitempty"`
   772  	// SuspensionReason: If the grant is suspended, the reason(s) for suspension.
   773  	SuspensionReason []string `json:"suspensionReason,omitempty"`
   774  	// ForceSendFields is a list of field names (e.g. "ChannelType") to
   775  	// unconditionally include in API requests. By default, fields with empty or
   776  	// default values are omitted from API requests. See
   777  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   778  	// details.
   779  	ForceSendFields []string `json:"-"`
   780  	// NullFields is a list of field names (e.g. "ChannelType") to include in API
   781  	// requests with the JSON null value. By default, fields with empty values are
   782  	// omitted from API requests. See
   783  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   784  	NullFields []string `json:"-"`
   785  }
   786  
   787  func (s *SasPortalDeviceGrant) MarshalJSON() ([]byte, error) {
   788  	type NoMethod SasPortalDeviceGrant
   789  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   790  }
   791  
   792  func (s *SasPortalDeviceGrant) UnmarshalJSON(data []byte) error {
   793  	type NoMethod SasPortalDeviceGrant
   794  	var s1 struct {
   795  		MaxEirp gensupport.JSONFloat64 `json:"maxEirp"`
   796  		*NoMethod
   797  	}
   798  	s1.NoMethod = (*NoMethod)(s)
   799  	if err := json.Unmarshal(data, &s1); err != nil {
   800  		return err
   801  	}
   802  	s.MaxEirp = float64(s1.MaxEirp)
   803  	return nil
   804  }
   805  
   806  // SasPortalDeviceMetadata: Device data overridable by both SAS Portal and
   807  // registration requests.
   808  type SasPortalDeviceMetadata struct {
   809  	// AntennaModel: If populated, the Antenna Model Pattern to use. Format is:
   810  	// `RecordCreatorId:PatternId`
   811  	AntennaModel string `json:"antennaModel,omitempty"`
   812  	// CommonChannelGroup: Common Channel Group (CCG). A group of CBSDs in the same
   813  	// ICG requesting a common primary channel assignment. For more details, see
   814  	// CBRSA-TS-2001 V3.0.0
   815  	// (https://ongoalliance.org/wp-content/uploads/2020/02/CBRSA-TS-2001-V3.0.0_Approved-for-publication.pdf).
   816  	CommonChannelGroup string `json:"commonChannelGroup,omitempty"`
   817  	// InterferenceCoordinationGroup: Interference Coordination Group (ICG). A
   818  	// group of CBSDs that manage their own interference with the group. For more
   819  	// details, see CBRSA-TS-2001 V3.0.0
   820  	// (https://ongoalliance.org/wp-content/uploads/2020/02/CBRSA-TS-2001-V3.0.0_Approved-for-publication.pdf).
   821  	InterferenceCoordinationGroup string `json:"interferenceCoordinationGroup,omitempty"`
   822  	// NrqzValidated: Output only. Set to `true` if a CPI has validated that they
   823  	// have coordinated with the National Quiet Zone office.
   824  	NrqzValidated bool `json:"nrqzValidated,omitempty"`
   825  	// NrqzValidation: Output only. National Radio Quiet Zone validation info.
   826  	NrqzValidation *SasPortalNrqzValidation `json:"nrqzValidation,omitempty"`
   827  	// ForceSendFields is a list of field names (e.g. "AntennaModel") to
   828  	// unconditionally include in API requests. By default, fields with empty or
   829  	// default values are omitted from API requests. See
   830  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   831  	// details.
   832  	ForceSendFields []string `json:"-"`
   833  	// NullFields is a list of field names (e.g. "AntennaModel") to include in API
   834  	// requests with the JSON null value. By default, fields with empty values are
   835  	// omitted from API requests. See
   836  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   837  	NullFields []string `json:"-"`
   838  }
   839  
   840  func (s *SasPortalDeviceMetadata) MarshalJSON() ([]byte, error) {
   841  	type NoMethod SasPortalDeviceMetadata
   842  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   843  }
   844  
   845  // SasPortalDeviceModel: Information about the model of the device.
   846  type SasPortalDeviceModel struct {
   847  	// FirmwareVersion: The firmware version of the device.
   848  	FirmwareVersion string `json:"firmwareVersion,omitempty"`
   849  	// HardwareVersion: The hardware version of the device.
   850  	HardwareVersion string `json:"hardwareVersion,omitempty"`
   851  	// Name: The name of the device model.
   852  	Name string `json:"name,omitempty"`
   853  	// SoftwareVersion: The software version of the device.
   854  	SoftwareVersion string `json:"softwareVersion,omitempty"`
   855  	// Vendor: The name of the device vendor.
   856  	Vendor string `json:"vendor,omitempty"`
   857  	// ForceSendFields is a list of field names (e.g. "FirmwareVersion") to
   858  	// unconditionally include in API requests. By default, fields with empty or
   859  	// default values are omitted from API requests. See
   860  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   861  	// details.
   862  	ForceSendFields []string `json:"-"`
   863  	// NullFields is a list of field names (e.g. "FirmwareVersion") to include in
   864  	// API requests with the JSON null value. By default, fields with empty values
   865  	// are omitted from API requests. See
   866  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   867  	NullFields []string `json:"-"`
   868  }
   869  
   870  func (s *SasPortalDeviceModel) MarshalJSON() ([]byte, error) {
   871  	type NoMethod SasPortalDeviceModel
   872  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   873  }
   874  
   875  // SasPortalDpaMoveList: An entry in a DPA's move list.
   876  type SasPortalDpaMoveList struct {
   877  	// DpaId: The ID of the DPA.
   878  	DpaId string `json:"dpaId,omitempty"`
   879  	// FrequencyRange: The frequency range that the move list affects.
   880  	FrequencyRange *SasPortalFrequencyRange `json:"frequencyRange,omitempty"`
   881  	// ForceSendFields is a list of field names (e.g. "DpaId") to unconditionally
   882  	// include in API requests. By default, fields with empty or default values are
   883  	// omitted from API requests. See
   884  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   885  	// details.
   886  	ForceSendFields []string `json:"-"`
   887  	// NullFields is a list of field names (e.g. "DpaId") to include in API
   888  	// requests with the JSON null value. By default, fields with empty values are
   889  	// omitted from API requests. See
   890  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   891  	NullFields []string `json:"-"`
   892  }
   893  
   894  func (s *SasPortalDpaMoveList) MarshalJSON() ([]byte, error) {
   895  	type NoMethod SasPortalDpaMoveList
   896  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   897  }
   898  
   899  // SasPortalEmpty: A generic empty message that you can re-use to avoid
   900  // defining duplicated empty messages in your APIs. A typical example is to use
   901  // it as the request or the response type of an API method. For instance:
   902  // service Foo { rpc Bar(google.protobuf.Empty) returns
   903  // (google.protobuf.Empty); }
   904  type SasPortalEmpty struct {
   905  	// ServerResponse contains the HTTP response code and headers from the server.
   906  	googleapi.ServerResponse `json:"-"`
   907  }
   908  
   909  // SasPortalFrequencyRange: Frequency range from `low_frequency` to
   910  // `high_frequency`.
   911  type SasPortalFrequencyRange struct {
   912  	// HighFrequencyMhz: The highest frequency of the frequency range in MHz.
   913  	HighFrequencyMhz float64 `json:"highFrequencyMhz,omitempty"`
   914  	// LowFrequencyMhz: The lowest frequency of the frequency range in MHz.
   915  	LowFrequencyMhz float64 `json:"lowFrequencyMhz,omitempty"`
   916  	// ForceSendFields is a list of field names (e.g. "HighFrequencyMhz") to
   917  	// unconditionally include in API requests. By default, fields with empty or
   918  	// default values are omitted from API requests. See
   919  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   920  	// details.
   921  	ForceSendFields []string `json:"-"`
   922  	// NullFields is a list of field names (e.g. "HighFrequencyMhz") to include in
   923  	// API requests with the JSON null value. By default, fields with empty values
   924  	// are omitted from API requests. See
   925  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   926  	NullFields []string `json:"-"`
   927  }
   928  
   929  func (s *SasPortalFrequencyRange) MarshalJSON() ([]byte, error) {
   930  	type NoMethod SasPortalFrequencyRange
   931  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   932  }
   933  
   934  func (s *SasPortalFrequencyRange) UnmarshalJSON(data []byte) error {
   935  	type NoMethod SasPortalFrequencyRange
   936  	var s1 struct {
   937  		HighFrequencyMhz gensupport.JSONFloat64 `json:"highFrequencyMhz"`
   938  		LowFrequencyMhz  gensupport.JSONFloat64 `json:"lowFrequencyMhz"`
   939  		*NoMethod
   940  	}
   941  	s1.NoMethod = (*NoMethod)(s)
   942  	if err := json.Unmarshal(data, &s1); err != nil {
   943  		return err
   944  	}
   945  	s.HighFrequencyMhz = float64(s1.HighFrequencyMhz)
   946  	s.LowFrequencyMhz = float64(s1.LowFrequencyMhz)
   947  	return nil
   948  }
   949  
   950  // SasPortalGcpProjectDeployment: Deployment associated with the GCP project.
   951  // Includes whether SAS analytics has been enabled or not.
   952  type SasPortalGcpProjectDeployment struct {
   953  	// Deployment: Deployment associated with the GCP project.
   954  	Deployment *SasPortalDeployment `json:"deployment,omitempty"`
   955  	// HasEnabledAnalytics: Whether SAS analytics has been enabled.
   956  	HasEnabledAnalytics bool `json:"hasEnabledAnalytics,omitempty"`
   957  	// ForceSendFields is a list of field names (e.g. "Deployment") 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. "Deployment") 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 *SasPortalGcpProjectDeployment) MarshalJSON() ([]byte, error) {
   971  	type NoMethod SasPortalGcpProjectDeployment
   972  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
   973  }
   974  
   975  // SasPortalGenerateSecretRequest: Request for GenerateSecret.
   976  type SasPortalGenerateSecretRequest struct {
   977  }
   978  
   979  // SasPortalGenerateSecretResponse: Response for GenerateSecret.
   980  type SasPortalGenerateSecretResponse struct {
   981  	// Secret: The secret generated by the string and used by ValidateInstaller.
   982  	Secret string `json:"secret,omitempty"`
   983  
   984  	// ServerResponse contains the HTTP response code and headers from the server.
   985  	googleapi.ServerResponse `json:"-"`
   986  	// ForceSendFields is a list of field names (e.g. "Secret") to unconditionally
   987  	// include in API requests. By default, fields with empty or default values are
   988  	// omitted from API requests. See
   989  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
   990  	// details.
   991  	ForceSendFields []string `json:"-"`
   992  	// NullFields is a list of field names (e.g. "Secret") to include in API
   993  	// requests with the JSON null value. By default, fields with empty values are
   994  	// omitted from API requests. See
   995  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
   996  	NullFields []string `json:"-"`
   997  }
   998  
   999  func (s *SasPortalGenerateSecretResponse) MarshalJSON() ([]byte, error) {
  1000  	type NoMethod SasPortalGenerateSecretResponse
  1001  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1002  }
  1003  
  1004  // SasPortalGetPolicyRequest: Request message for `GetPolicy` method.
  1005  type SasPortalGetPolicyRequest struct {
  1006  	// Resource: Required. The resource for which the policy is being requested.
  1007  	Resource string `json:"resource,omitempty"`
  1008  	// ForceSendFields is a list of field names (e.g. "Resource") to
  1009  	// unconditionally include in API requests. By default, fields with empty or
  1010  	// default values are omitted from API requests. See
  1011  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1012  	// details.
  1013  	ForceSendFields []string `json:"-"`
  1014  	// NullFields is a list of field names (e.g. "Resource") to include in API
  1015  	// requests with the JSON null value. By default, fields with empty values are
  1016  	// omitted from API requests. See
  1017  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1018  	NullFields []string `json:"-"`
  1019  }
  1020  
  1021  func (s *SasPortalGetPolicyRequest) MarshalJSON() ([]byte, error) {
  1022  	type NoMethod SasPortalGetPolicyRequest
  1023  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1024  }
  1025  
  1026  // SasPortalInstallationParams: Information about the device installation
  1027  // parameters.
  1028  type SasPortalInstallationParams struct {
  1029  	// AntennaAzimuth: Boresight direction of the horizontal plane of the antenna
  1030  	// in degrees with respect to true north. The value of this parameter is an
  1031  	// integer with a value between 0 and 359 inclusive. A value of 0 degrees means
  1032  	// true north; a value of 90 degrees means east. This parameter is optional for
  1033  	// Category A devices and conditional for Category B devices.
  1034  	AntennaAzimuth int64 `json:"antennaAzimuth,omitempty"`
  1035  	// AntennaBeamwidth: 3-dB antenna beamwidth of the antenna in the
  1036  	// horizontal-plane in degrees. This parameter is an unsigned integer having a
  1037  	// value between 0 and 360 (degrees) inclusive; it is optional for Category A
  1038  	// devices and conditional for Category B devices.
  1039  	AntennaBeamwidth int64 `json:"antennaBeamwidth,omitempty"`
  1040  	// AntennaDowntilt: Antenna downtilt in degrees and is an integer with a value
  1041  	// between -90 and +90 inclusive; a negative value means the antenna is tilted
  1042  	// up (above horizontal). This parameter is optional for Category A devices and
  1043  	// conditional for Category B devices.
  1044  	AntennaDowntilt int64 `json:"antennaDowntilt,omitempty"`
  1045  	// AntennaGain: Peak antenna gain in dBi. This parameter is an integer with a
  1046  	// value between -127 and +128 (dBi) inclusive.
  1047  	AntennaGain int64 `json:"antennaGain,omitempty"`
  1048  	// AntennaModel: If an external antenna is used, the antenna model is
  1049  	// optionally provided in this field. The string has a maximum length of 128
  1050  	// octets.
  1051  	AntennaModel string `json:"antennaModel,omitempty"`
  1052  	// CpeCbsdIndication: If present, this parameter specifies whether the CBSD is
  1053  	// a CPE-CBSD or not.
  1054  	CpeCbsdIndication bool `json:"cpeCbsdIndication,omitempty"`
  1055  	// EirpCapability: This parameter is the maximum device EIRP in units of
  1056  	// dBm/10MHz and is an integer with a value between -127 and +47 (dBm/10 MHz)
  1057  	// inclusive. If not included, SAS interprets it as maximum allowable EIRP in
  1058  	// units of dBm/10MHz for device category.
  1059  	EirpCapability int64 `json:"eirpCapability,omitempty"`
  1060  	// Height: Device antenna height in meters. When the `heightType` parameter
  1061  	// value is "AGL", the antenna height should be given relative to ground level.
  1062  	// When the `heightType` parameter value is "AMSL", it is given with respect to
  1063  	// WGS84 datum.
  1064  	Height float64 `json:"height,omitempty"`
  1065  	// HeightType: Specifies how the height is measured.
  1066  	//
  1067  	// Possible values:
  1068  	//   "HEIGHT_TYPE_UNSPECIFIED" - Unspecified height type.
  1069  	//   "HEIGHT_TYPE_AGL" - AGL height is measured relative to the ground level.
  1070  	//   "HEIGHT_TYPE_AMSL" - AMSL height is measured relative to the mean sea
  1071  	// level.
  1072  	HeightType string `json:"heightType,omitempty"`
  1073  	// HorizontalAccuracy: A positive number in meters to indicate accuracy of the
  1074  	// device antenna horizontal location. This optional parameter should only be
  1075  	// present if its value is less than the FCC requirement of 50 meters.
  1076  	HorizontalAccuracy float64 `json:"horizontalAccuracy,omitempty"`
  1077  	// IndoorDeployment: Whether the device antenna is indoor or not. `true`:
  1078  	// indoor. `false`: outdoor.
  1079  	IndoorDeployment bool `json:"indoorDeployment,omitempty"`
  1080  	// Latitude: Latitude of the device antenna location in degrees relative to the
  1081  	// WGS 84 datum. The allowed range is from -90.000000 to +90.000000. Positive
  1082  	// values represent latitudes north of the equator; negative values south of
  1083  	// the equator.
  1084  	Latitude float64 `json:"latitude,omitempty"`
  1085  	// Longitude: Longitude of the device antenna location in degrees relative to
  1086  	// the WGS 84 datum. The allowed range is from -180.000000 to +180.000000.
  1087  	// Positive values represent longitudes east of the prime meridian; negative
  1088  	// values west of the prime meridian.
  1089  	Longitude float64 `json:"longitude,omitempty"`
  1090  	// VerticalAccuracy: A positive number in meters to indicate accuracy of the
  1091  	// device antenna vertical location. This optional parameter should only be
  1092  	// present if its value is less than the FCC requirement of 3 meters.
  1093  	VerticalAccuracy float64 `json:"verticalAccuracy,omitempty"`
  1094  	// ForceSendFields is a list of field names (e.g. "AntennaAzimuth") to
  1095  	// unconditionally include in API requests. By default, fields with empty or
  1096  	// default values are omitted from API requests. See
  1097  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1098  	// details.
  1099  	ForceSendFields []string `json:"-"`
  1100  	// NullFields is a list of field names (e.g. "AntennaAzimuth") to include in
  1101  	// API requests with the JSON null value. By default, fields with empty values
  1102  	// are omitted from API requests. See
  1103  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1104  	NullFields []string `json:"-"`
  1105  }
  1106  
  1107  func (s *SasPortalInstallationParams) MarshalJSON() ([]byte, error) {
  1108  	type NoMethod SasPortalInstallationParams
  1109  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1110  }
  1111  
  1112  func (s *SasPortalInstallationParams) UnmarshalJSON(data []byte) error {
  1113  	type NoMethod SasPortalInstallationParams
  1114  	var s1 struct {
  1115  		Height             gensupport.JSONFloat64 `json:"height"`
  1116  		HorizontalAccuracy gensupport.JSONFloat64 `json:"horizontalAccuracy"`
  1117  		Latitude           gensupport.JSONFloat64 `json:"latitude"`
  1118  		Longitude          gensupport.JSONFloat64 `json:"longitude"`
  1119  		VerticalAccuracy   gensupport.JSONFloat64 `json:"verticalAccuracy"`
  1120  		*NoMethod
  1121  	}
  1122  	s1.NoMethod = (*NoMethod)(s)
  1123  	if err := json.Unmarshal(data, &s1); err != nil {
  1124  		return err
  1125  	}
  1126  	s.Height = float64(s1.Height)
  1127  	s.HorizontalAccuracy = float64(s1.HorizontalAccuracy)
  1128  	s.Latitude = float64(s1.Latitude)
  1129  	s.Longitude = float64(s1.Longitude)
  1130  	s.VerticalAccuracy = float64(s1.VerticalAccuracy)
  1131  	return nil
  1132  }
  1133  
  1134  // SasPortalListCustomersResponse: Response for `ListCustomers`.
  1135  type SasPortalListCustomersResponse struct {
  1136  	// Customers: The list of customers that match the request.
  1137  	Customers []*SasPortalCustomer `json:"customers,omitempty"`
  1138  	// NextPageToken: A pagination token returned from a previous call to
  1139  	// ListCustomers that indicates from where listing should continue. If the
  1140  	// field is missing or empty, it means there are no more customers.
  1141  	NextPageToken string `json:"nextPageToken,omitempty"`
  1142  
  1143  	// ServerResponse contains the HTTP response code and headers from the server.
  1144  	googleapi.ServerResponse `json:"-"`
  1145  	// ForceSendFields is a list of field names (e.g. "Customers") to
  1146  	// unconditionally include in API requests. By default, fields with empty or
  1147  	// default values are omitted from API requests. See
  1148  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1149  	// details.
  1150  	ForceSendFields []string `json:"-"`
  1151  	// NullFields is a list of field names (e.g. "Customers") to include in API
  1152  	// requests with the JSON null value. By default, fields with empty values are
  1153  	// omitted from API requests. See
  1154  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1155  	NullFields []string `json:"-"`
  1156  }
  1157  
  1158  func (s *SasPortalListCustomersResponse) MarshalJSON() ([]byte, error) {
  1159  	type NoMethod SasPortalListCustomersResponse
  1160  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1161  }
  1162  
  1163  // SasPortalListDeploymentsResponse: Response for ListDeployments.
  1164  type SasPortalListDeploymentsResponse struct {
  1165  	// Deployments: The deployments that match the request.
  1166  	Deployments []*SasPortalDeployment `json:"deployments,omitempty"`
  1167  	// NextPageToken: A pagination token returned from a previous call to
  1168  	// ListDeployments that indicates from where listing should continue. If the
  1169  	// field is missing or empty, it means there are no more deployments.
  1170  	NextPageToken string `json:"nextPageToken,omitempty"`
  1171  
  1172  	// ServerResponse contains the HTTP response code and headers from the server.
  1173  	googleapi.ServerResponse `json:"-"`
  1174  	// ForceSendFields is a list of field names (e.g. "Deployments") to
  1175  	// unconditionally include in API requests. By default, fields with empty or
  1176  	// default values are omitted from API requests. See
  1177  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1178  	// details.
  1179  	ForceSendFields []string `json:"-"`
  1180  	// NullFields is a list of field names (e.g. "Deployments") to include in API
  1181  	// requests with the JSON null value. By default, fields with empty values are
  1182  	// omitted from API requests. See
  1183  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1184  	NullFields []string `json:"-"`
  1185  }
  1186  
  1187  func (s *SasPortalListDeploymentsResponse) MarshalJSON() ([]byte, error) {
  1188  	type NoMethod SasPortalListDeploymentsResponse
  1189  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1190  }
  1191  
  1192  // SasPortalListDevicesResponse: Response for ListDevices.
  1193  type SasPortalListDevicesResponse struct {
  1194  	// Devices: The devices that match the request.
  1195  	Devices []*SasPortalDevice `json:"devices,omitempty"`
  1196  	// NextPageToken: A pagination token returned from a previous call to
  1197  	// ListDevices that indicates from where listing should continue. If the field
  1198  	// is missing or empty, it means there is no more devices.
  1199  	NextPageToken string `json:"nextPageToken,omitempty"`
  1200  
  1201  	// ServerResponse contains the HTTP response code and headers from the server.
  1202  	googleapi.ServerResponse `json:"-"`
  1203  	// ForceSendFields is a list of field names (e.g. "Devices") to unconditionally
  1204  	// include in API requests. By default, fields with empty or default values are
  1205  	// omitted from API requests. See
  1206  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1207  	// details.
  1208  	ForceSendFields []string `json:"-"`
  1209  	// NullFields is a list of field names (e.g. "Devices") to include in API
  1210  	// requests with the JSON null value. By default, fields with empty values are
  1211  	// omitted from API requests. See
  1212  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1213  	NullFields []string `json:"-"`
  1214  }
  1215  
  1216  func (s *SasPortalListDevicesResponse) MarshalJSON() ([]byte, error) {
  1217  	type NoMethod SasPortalListDevicesResponse
  1218  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1219  }
  1220  
  1221  // SasPortalListGcpProjectDeploymentsResponse: Response for
  1222  // [ListGcpProjectDeployments].
  1223  type SasPortalListGcpProjectDeploymentsResponse struct {
  1224  	// Deployments: Optional. Deployments associated with the GCP project
  1225  	Deployments []*SasPortalGcpProjectDeployment `json:"deployments,omitempty"`
  1226  
  1227  	// ServerResponse contains the HTTP response code and headers from the server.
  1228  	googleapi.ServerResponse `json:"-"`
  1229  	// ForceSendFields is a list of field names (e.g. "Deployments") to
  1230  	// unconditionally include in API requests. By default, fields with empty or
  1231  	// default values are omitted from API requests. See
  1232  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1233  	// details.
  1234  	ForceSendFields []string `json:"-"`
  1235  	// NullFields is a list of field names (e.g. "Deployments") to include in API
  1236  	// requests with the JSON null value. By default, fields with empty values are
  1237  	// omitted from API requests. See
  1238  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1239  	NullFields []string `json:"-"`
  1240  }
  1241  
  1242  func (s *SasPortalListGcpProjectDeploymentsResponse) MarshalJSON() ([]byte, error) {
  1243  	type NoMethod SasPortalListGcpProjectDeploymentsResponse
  1244  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1245  }
  1246  
  1247  // SasPortalListLegacyOrganizationsResponse: Response for
  1248  // [ListLegacyOrganizations].
  1249  // [spectrum.sas.portal.v1alpha1.Provisioning.ListLegacyOrganizations].
  1250  type SasPortalListLegacyOrganizationsResponse struct {
  1251  	// Organizations: Optional. Legacy SAS organizations.
  1252  	Organizations []*SasPortalOrganization `json:"organizations,omitempty"`
  1253  
  1254  	// ServerResponse contains the HTTP response code and headers from the server.
  1255  	googleapi.ServerResponse `json:"-"`
  1256  	// ForceSendFields is a list of field names (e.g. "Organizations") to
  1257  	// unconditionally include in API requests. By default, fields with empty or
  1258  	// default values are omitted from API requests. See
  1259  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1260  	// details.
  1261  	ForceSendFields []string `json:"-"`
  1262  	// NullFields is a list of field names (e.g. "Organizations") to include in API
  1263  	// requests with the JSON null value. By default, fields with empty values are
  1264  	// omitted from API requests. See
  1265  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1266  	NullFields []string `json:"-"`
  1267  }
  1268  
  1269  func (s *SasPortalListLegacyOrganizationsResponse) MarshalJSON() ([]byte, error) {
  1270  	type NoMethod SasPortalListLegacyOrganizationsResponse
  1271  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1272  }
  1273  
  1274  // SasPortalListNodesResponse: Response for ListNodes.
  1275  type SasPortalListNodesResponse struct {
  1276  	// NextPageToken: A pagination token returned from a previous call to ListNodes
  1277  	// that indicates from where listing should continue. If the field is missing
  1278  	// or empty, it means there is no more nodes.
  1279  	NextPageToken string `json:"nextPageToken,omitempty"`
  1280  	// Nodes: The nodes that match the request.
  1281  	Nodes []*SasPortalNode `json:"nodes,omitempty"`
  1282  
  1283  	// ServerResponse contains the HTTP response code and headers from the server.
  1284  	googleapi.ServerResponse `json:"-"`
  1285  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
  1286  	// unconditionally include in API requests. By default, fields with empty or
  1287  	// default values are omitted from API requests. See
  1288  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1289  	// details.
  1290  	ForceSendFields []string `json:"-"`
  1291  	// NullFields is a list of field names (e.g. "NextPageToken") to include in API
  1292  	// requests with the JSON null value. By default, fields with empty values are
  1293  	// omitted from API requests. See
  1294  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1295  	NullFields []string `json:"-"`
  1296  }
  1297  
  1298  func (s *SasPortalListNodesResponse) MarshalJSON() ([]byte, error) {
  1299  	type NoMethod SasPortalListNodesResponse
  1300  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1301  }
  1302  
  1303  // SasPortalMigrateOrganizationMetadata: Long-running operation metadata
  1304  // message returned by the MigrateOrganization.
  1305  type SasPortalMigrateOrganizationMetadata struct {
  1306  	// OperationState: Output only. Current operation state
  1307  	//
  1308  	// Possible values:
  1309  	//   "OPERATION_STATE_UNSPECIFIED" - Unspecified.
  1310  	//   "OPERATION_STATE_PENDING" - Pending (Not started).
  1311  	//   "OPERATION_STATE_RUNNING" - In-progress.
  1312  	//   "OPERATION_STATE_SUCCEEDED" - Done successfully.
  1313  	//   "OPERATION_STATE_FAILED" - Done with errors.
  1314  	OperationState string `json:"operationState,omitempty"`
  1315  	// ForceSendFields is a list of field names (e.g. "OperationState") to
  1316  	// unconditionally include in API requests. By default, fields with empty or
  1317  	// default values are omitted from API requests. See
  1318  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1319  	// details.
  1320  	ForceSendFields []string `json:"-"`
  1321  	// NullFields is a list of field names (e.g. "OperationState") to include in
  1322  	// API requests with the JSON null value. By default, fields with empty values
  1323  	// are omitted from API requests. See
  1324  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1325  	NullFields []string `json:"-"`
  1326  }
  1327  
  1328  func (s *SasPortalMigrateOrganizationMetadata) MarshalJSON() ([]byte, error) {
  1329  	type NoMethod SasPortalMigrateOrganizationMetadata
  1330  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1331  }
  1332  
  1333  // SasPortalMigrateOrganizationRequest: Request for [MigrateOrganization].
  1334  // [spectrum.sas.portal.v1alpha1.Provisioning.MigrateOrganization]. GCP
  1335  // Project, Organization Info, and caller's GAIA ID should be retrieved from
  1336  // the RPC handler, and used to check authorization on SAS Portal organization
  1337  // and to create GCP Projects.
  1338  type SasPortalMigrateOrganizationRequest struct {
  1339  	// OrganizationId: Required. Id of the SAS organization to be migrated.
  1340  	OrganizationId int64 `json:"organizationId,omitempty,string"`
  1341  	// ForceSendFields is a list of field names (e.g. "OrganizationId") to
  1342  	// unconditionally include in API requests. By default, fields with empty or
  1343  	// default values are omitted from API requests. See
  1344  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1345  	// details.
  1346  	ForceSendFields []string `json:"-"`
  1347  	// NullFields is a list of field names (e.g. "OrganizationId") to include in
  1348  	// API requests with the JSON null value. By default, fields with empty values
  1349  	// are omitted from API requests. See
  1350  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1351  	NullFields []string `json:"-"`
  1352  }
  1353  
  1354  func (s *SasPortalMigrateOrganizationRequest) MarshalJSON() ([]byte, error) {
  1355  	type NoMethod SasPortalMigrateOrganizationRequest
  1356  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1357  }
  1358  
  1359  // SasPortalMigrateOrganizationResponse: Response for [MigrateOrganization].
  1360  // [spectrum.sas.portal.v1alpha1.Provisioning.MigrateOrganization].
  1361  type SasPortalMigrateOrganizationResponse struct {
  1362  	// DeploymentAssociation: Optional. A list of deployment association that were
  1363  	// created for the migration, or current associations if they already exist.
  1364  	DeploymentAssociation []*SasPortalDeploymentAssociation `json:"deploymentAssociation,omitempty"`
  1365  	// ForceSendFields is a list of field names (e.g. "DeploymentAssociation") to
  1366  	// unconditionally include in API requests. By default, fields with empty or
  1367  	// default values are omitted from API requests. See
  1368  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1369  	// details.
  1370  	ForceSendFields []string `json:"-"`
  1371  	// NullFields is a list of field names (e.g. "DeploymentAssociation") to
  1372  	// include in API requests with the JSON null value. By default, fields with
  1373  	// empty values are omitted from API requests. See
  1374  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1375  	NullFields []string `json:"-"`
  1376  }
  1377  
  1378  func (s *SasPortalMigrateOrganizationResponse) MarshalJSON() ([]byte, error) {
  1379  	type NoMethod SasPortalMigrateOrganizationResponse
  1380  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1381  }
  1382  
  1383  // SasPortalMoveDeploymentRequest: Request for MoveDeployment.
  1384  type SasPortalMoveDeploymentRequest struct {
  1385  	// Destination: Required. The name of the new parent resource node or customer
  1386  	// to reparent the deployment under.
  1387  	Destination string `json:"destination,omitempty"`
  1388  	// ForceSendFields is a list of field names (e.g. "Destination") to
  1389  	// unconditionally include in API requests. By default, fields with empty or
  1390  	// default values are omitted from API requests. See
  1391  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1392  	// details.
  1393  	ForceSendFields []string `json:"-"`
  1394  	// NullFields is a list of field names (e.g. "Destination") to include in API
  1395  	// requests with the JSON null value. By default, fields with empty values are
  1396  	// omitted from API requests. See
  1397  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1398  	NullFields []string `json:"-"`
  1399  }
  1400  
  1401  func (s *SasPortalMoveDeploymentRequest) MarshalJSON() ([]byte, error) {
  1402  	type NoMethod SasPortalMoveDeploymentRequest
  1403  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1404  }
  1405  
  1406  // SasPortalMoveDeviceRequest: Request for MoveDevice.
  1407  type SasPortalMoveDeviceRequest struct {
  1408  	// Destination: Required. The name of the new parent resource node or customer
  1409  	// to reparent the device under.
  1410  	Destination string `json:"destination,omitempty"`
  1411  	// ForceSendFields is a list of field names (e.g. "Destination") to
  1412  	// unconditionally include in API requests. By default, fields with empty or
  1413  	// default values are omitted from API requests. See
  1414  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1415  	// details.
  1416  	ForceSendFields []string `json:"-"`
  1417  	// NullFields is a list of field names (e.g. "Destination") to include in API
  1418  	// requests with the JSON null value. By default, fields with empty values are
  1419  	// omitted from API requests. See
  1420  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1421  	NullFields []string `json:"-"`
  1422  }
  1423  
  1424  func (s *SasPortalMoveDeviceRequest) MarshalJSON() ([]byte, error) {
  1425  	type NoMethod SasPortalMoveDeviceRequest
  1426  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1427  }
  1428  
  1429  // SasPortalMoveNodeRequest: Request for MoveNode.
  1430  type SasPortalMoveNodeRequest struct {
  1431  	// Destination: Required. The name of the new parent resource node or customer
  1432  	// to reparent the node under.
  1433  	Destination string `json:"destination,omitempty"`
  1434  	// ForceSendFields is a list of field names (e.g. "Destination") to
  1435  	// unconditionally include in API requests. By default, fields with empty or
  1436  	// default values are omitted from API requests. See
  1437  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1438  	// details.
  1439  	ForceSendFields []string `json:"-"`
  1440  	// NullFields is a list of field names (e.g. "Destination") to include in API
  1441  	// requests with the JSON null value. By default, fields with empty values are
  1442  	// omitted from API requests. See
  1443  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1444  	NullFields []string `json:"-"`
  1445  }
  1446  
  1447  func (s *SasPortalMoveNodeRequest) MarshalJSON() ([]byte, error) {
  1448  	type NoMethod SasPortalMoveNodeRequest
  1449  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1450  }
  1451  
  1452  // SasPortalNode: The Node.
  1453  type SasPortalNode struct {
  1454  	// DisplayName: The node's display name.
  1455  	DisplayName string `json:"displayName,omitempty"`
  1456  	// Name: Output only. Resource name.
  1457  	Name string `json:"name,omitempty"`
  1458  	// SasUserIds: User ids used by the devices belonging to this node.
  1459  	SasUserIds []string `json:"sasUserIds,omitempty"`
  1460  
  1461  	// ServerResponse contains the HTTP response code and headers from the server.
  1462  	googleapi.ServerResponse `json:"-"`
  1463  	// ForceSendFields is a list of field names (e.g. "DisplayName") to
  1464  	// unconditionally include in API requests. By default, fields with empty or
  1465  	// default values are omitted from API requests. See
  1466  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1467  	// details.
  1468  	ForceSendFields []string `json:"-"`
  1469  	// NullFields is a list of field names (e.g. "DisplayName") to include in API
  1470  	// requests with the JSON null value. By default, fields with empty values are
  1471  	// omitted from API requests. See
  1472  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1473  	NullFields []string `json:"-"`
  1474  }
  1475  
  1476  func (s *SasPortalNode) MarshalJSON() ([]byte, error) {
  1477  	type NoMethod SasPortalNode
  1478  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1479  }
  1480  
  1481  // SasPortalNrqzValidation: Information about National Radio Quiet Zone
  1482  // validation.
  1483  type SasPortalNrqzValidation struct {
  1484  	// CaseId: Validation case ID.
  1485  	CaseId string `json:"caseId,omitempty"`
  1486  	// CpiId: CPI who signed the validation.
  1487  	CpiId string `json:"cpiId,omitempty"`
  1488  	// Latitude: Device latitude that's associated with the validation.
  1489  	Latitude float64 `json:"latitude,omitempty"`
  1490  	// Longitude: Device longitude that's associated with the validation.
  1491  	Longitude float64 `json:"longitude,omitempty"`
  1492  	// State: State of the NRQZ validation info.
  1493  	//
  1494  	// Possible values:
  1495  	//   "STATE_UNSPECIFIED" - Unspecified state.
  1496  	//   "DRAFT" - Draft state.
  1497  	//   "FINAL" - Final state.
  1498  	State string `json:"state,omitempty"`
  1499  	// ForceSendFields is a list of field names (e.g. "CaseId") to unconditionally
  1500  	// include in API requests. By default, fields with empty or default values are
  1501  	// omitted from API requests. See
  1502  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1503  	// details.
  1504  	ForceSendFields []string `json:"-"`
  1505  	// NullFields is a list of field names (e.g. "CaseId") to include in API
  1506  	// requests with the JSON null value. By default, fields with empty values are
  1507  	// omitted from API requests. See
  1508  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1509  	NullFields []string `json:"-"`
  1510  }
  1511  
  1512  func (s *SasPortalNrqzValidation) MarshalJSON() ([]byte, error) {
  1513  	type NoMethod SasPortalNrqzValidation
  1514  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1515  }
  1516  
  1517  func (s *SasPortalNrqzValidation) UnmarshalJSON(data []byte) error {
  1518  	type NoMethod SasPortalNrqzValidation
  1519  	var s1 struct {
  1520  		Latitude  gensupport.JSONFloat64 `json:"latitude"`
  1521  		Longitude gensupport.JSONFloat64 `json:"longitude"`
  1522  		*NoMethod
  1523  	}
  1524  	s1.NoMethod = (*NoMethod)(s)
  1525  	if err := json.Unmarshal(data, &s1); err != nil {
  1526  		return err
  1527  	}
  1528  	s.Latitude = float64(s1.Latitude)
  1529  	s.Longitude = float64(s1.Longitude)
  1530  	return nil
  1531  }
  1532  
  1533  // SasPortalOperation: This resource represents a long-running operation that
  1534  // is the result of a network API call.
  1535  type SasPortalOperation struct {
  1536  	// Done: If the value is `false`, it means the operation is still in progress.
  1537  	// If `true`, the operation is completed, and either `error` or `response` is
  1538  	// available.
  1539  	Done bool `json:"done,omitempty"`
  1540  	// Error: The error result of the operation in case of failure or cancellation.
  1541  	Error *SasPortalStatus `json:"error,omitempty"`
  1542  	// Metadata: Service-specific metadata associated with the operation. It
  1543  	// typically contains progress information and common metadata such as create
  1544  	// time. Some services might not provide such metadata. Any method that returns
  1545  	// a long-running operation should document the metadata type, if any.
  1546  	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
  1547  	// Name: The server-assigned name, which is only unique within the same service
  1548  	// that originally returns it. If you use the default HTTP mapping, the `name`
  1549  	// should be a resource name ending with `operations/{unique_id}`.
  1550  	Name string `json:"name,omitempty"`
  1551  	// Response: The normal, successful response of the operation. If the original
  1552  	// method returns no data on success, such as `Delete`, the response is
  1553  	// `google.protobuf.Empty`. If the original method is standard
  1554  	// `Get`/`Create`/`Update`, the response should be the resource. For other
  1555  	// methods, the response should have the type `XxxResponse`, where `Xxx` is the
  1556  	// original method name. For example, if the original method name is
  1557  	// `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
  1558  	Response googleapi.RawMessage `json:"response,omitempty"`
  1559  
  1560  	// ServerResponse contains the HTTP response code and headers from the server.
  1561  	googleapi.ServerResponse `json:"-"`
  1562  	// ForceSendFields is a list of field names (e.g. "Done") to unconditionally
  1563  	// include in API requests. By default, fields with empty or default values are
  1564  	// omitted from API requests. See
  1565  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1566  	// details.
  1567  	ForceSendFields []string `json:"-"`
  1568  	// NullFields is a list of field names (e.g. "Done") to include in API requests
  1569  	// with the JSON null value. By default, fields with empty values are omitted
  1570  	// from API requests. See
  1571  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1572  	NullFields []string `json:"-"`
  1573  }
  1574  
  1575  func (s *SasPortalOperation) MarshalJSON() ([]byte, error) {
  1576  	type NoMethod SasPortalOperation
  1577  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1578  }
  1579  
  1580  // SasPortalOrganization: Organization details.
  1581  type SasPortalOrganization struct {
  1582  	// DisplayName: Name of organization
  1583  	DisplayName string `json:"displayName,omitempty"`
  1584  	// Id: Id of organization
  1585  	Id int64 `json:"id,omitempty,string"`
  1586  	// ForceSendFields is a list of field names (e.g. "DisplayName") to
  1587  	// unconditionally include in API requests. By default, fields with empty or
  1588  	// default values are omitted from API requests. See
  1589  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1590  	// details.
  1591  	ForceSendFields []string `json:"-"`
  1592  	// NullFields is a list of field names (e.g. "DisplayName") to include in API
  1593  	// requests with the JSON null value. By default, fields with empty values are
  1594  	// omitted from API requests. See
  1595  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1596  	NullFields []string `json:"-"`
  1597  }
  1598  
  1599  func (s *SasPortalOrganization) MarshalJSON() ([]byte, error) {
  1600  	type NoMethod SasPortalOrganization
  1601  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1602  }
  1603  
  1604  // SasPortalPolicy: Defines an access control policy to the resources.
  1605  type SasPortalPolicy struct {
  1606  	// Assignments: List of assignments
  1607  	Assignments []*SasPortalAssignment `json:"assignments,omitempty"`
  1608  	// Etag: The etag is used for optimistic concurrency control as a way to help
  1609  	// prevent simultaneous updates of a policy from overwriting each other. It is
  1610  	// strongly suggested that systems make use of the etag in the
  1611  	// read-modify-write cycle to perform policy updates in order to avoid race
  1612  	// conditions: An etag is returned in the response to GetPolicy, and systems
  1613  	// are expected to put that etag in the request to SetPolicy to ensure that
  1614  	// their change will be applied to the same version of the policy. If no etag
  1615  	// is provided in the call to GetPolicy, then the existing policy is
  1616  	// overwritten blindly.
  1617  	Etag string `json:"etag,omitempty"`
  1618  
  1619  	// ServerResponse contains the HTTP response code and headers from the server.
  1620  	googleapi.ServerResponse `json:"-"`
  1621  	// ForceSendFields is a list of field names (e.g. "Assignments") to
  1622  	// unconditionally include in API requests. By default, fields with empty or
  1623  	// default values are omitted from API requests. See
  1624  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1625  	// details.
  1626  	ForceSendFields []string `json:"-"`
  1627  	// NullFields is a list of field names (e.g. "Assignments") to include in API
  1628  	// requests with the JSON null value. By default, fields with empty values are
  1629  	// omitted from API requests. See
  1630  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1631  	NullFields []string `json:"-"`
  1632  }
  1633  
  1634  func (s *SasPortalPolicy) MarshalJSON() ([]byte, error) {
  1635  	type NoMethod SasPortalPolicy
  1636  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1637  }
  1638  
  1639  // SasPortalProvisionDeploymentRequest: Request for [ProvisionDeployment].
  1640  // [spectrum.sas.portal.v1alpha1.Provisioning.ProvisionDeployment]. GCP
  1641  // Project, Organization Info, and caller’s GAIA ID should be retrieved from
  1642  // the RPC handler, and used as inputs to create a new SAS organization (if not
  1643  // exists) and a new SAS deployment.
  1644  type SasPortalProvisionDeploymentRequest struct {
  1645  	// NewDeploymentDisplayName: Optional. If this field is set, and a new SAS
  1646  	// Portal Deployment needs to be created, its display name will be set to the
  1647  	// value of this field.
  1648  	NewDeploymentDisplayName string `json:"newDeploymentDisplayName,omitempty"`
  1649  	// NewOrganizationDisplayName: Optional. If this field is set, and a new SAS
  1650  	// Portal Organization needs to be created, its display name will be set to the
  1651  	// value of this field.
  1652  	NewOrganizationDisplayName string `json:"newOrganizationDisplayName,omitempty"`
  1653  	// OrganizationId: Optional. If this field is set then a new deployment will be
  1654  	// created under the organization specified by this id.
  1655  	OrganizationId int64 `json:"organizationId,omitempty,string"`
  1656  	// ForceSendFields is a list of field names (e.g. "NewDeploymentDisplayName")
  1657  	// to unconditionally include in API requests. By default, fields with empty or
  1658  	// default values are omitted from API requests. See
  1659  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1660  	// details.
  1661  	ForceSendFields []string `json:"-"`
  1662  	// NullFields is a list of field names (e.g. "NewDeploymentDisplayName") to
  1663  	// include in API requests with the JSON null value. By default, fields with
  1664  	// empty values are omitted from API requests. See
  1665  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1666  	NullFields []string `json:"-"`
  1667  }
  1668  
  1669  func (s *SasPortalProvisionDeploymentRequest) MarshalJSON() ([]byte, error) {
  1670  	type NoMethod SasPortalProvisionDeploymentRequest
  1671  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1672  }
  1673  
  1674  // SasPortalProvisionDeploymentResponse: Response for [ProvisionDeployment].
  1675  // [spectrum.sas.portal.v1alpha1.Provisioning.ProvisionDeployment].
  1676  type SasPortalProvisionDeploymentResponse struct {
  1677  	// ErrorMessage: Optional. Optional error message if the provisioning request
  1678  	// is not successful.
  1679  	ErrorMessage string `json:"errorMessage,omitempty"`
  1680  
  1681  	// ServerResponse contains the HTTP response code and headers from the server.
  1682  	googleapi.ServerResponse `json:"-"`
  1683  	// ForceSendFields is a list of field names (e.g. "ErrorMessage") to
  1684  	// unconditionally include in API requests. By default, fields with empty or
  1685  	// default values are omitted from API requests. See
  1686  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1687  	// details.
  1688  	ForceSendFields []string `json:"-"`
  1689  	// NullFields is a list of field names (e.g. "ErrorMessage") to include in API
  1690  	// requests with the JSON null value. By default, fields with empty values are
  1691  	// omitted from API requests. See
  1692  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1693  	NullFields []string `json:"-"`
  1694  }
  1695  
  1696  func (s *SasPortalProvisionDeploymentResponse) MarshalJSON() ([]byte, error) {
  1697  	type NoMethod SasPortalProvisionDeploymentResponse
  1698  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1699  }
  1700  
  1701  // SasPortalSetPolicyRequest: Request message for `SetPolicy` method.
  1702  type SasPortalSetPolicyRequest struct {
  1703  	// DisableNotification: Optional. Set the field as `true` to disable the
  1704  	// onboarding notification.
  1705  	DisableNotification bool `json:"disableNotification,omitempty"`
  1706  	// Policy: Required. The policy to be applied to the `resource`.
  1707  	Policy *SasPortalPolicy `json:"policy,omitempty"`
  1708  	// Resource: Required. The resource for which the policy is being specified.
  1709  	// This policy replaces any existing policy.
  1710  	Resource string `json:"resource,omitempty"`
  1711  	// ForceSendFields is a list of field names (e.g. "DisableNotification") to
  1712  	// unconditionally include in API requests. By default, fields with empty or
  1713  	// default values are omitted from API requests. See
  1714  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1715  	// details.
  1716  	ForceSendFields []string `json:"-"`
  1717  	// NullFields is a list of field names (e.g. "DisableNotification") to include
  1718  	// in API requests with the JSON null value. By default, fields with empty
  1719  	// values are omitted from API requests. See
  1720  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1721  	NullFields []string `json:"-"`
  1722  }
  1723  
  1724  func (s *SasPortalSetPolicyRequest) MarshalJSON() ([]byte, error) {
  1725  	type NoMethod SasPortalSetPolicyRequest
  1726  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1727  }
  1728  
  1729  // SasPortalSetupSasAnalyticsMetadata: Metadata returned by the long running
  1730  // operation for the SetupSasAnalytics rpc.
  1731  type SasPortalSetupSasAnalyticsMetadata struct {
  1732  }
  1733  
  1734  // SasPortalSetupSasAnalyticsRequest: Request for the SetupSasAnalytics rpc.
  1735  type SasPortalSetupSasAnalyticsRequest struct {
  1736  	// UserId: Optional. User id to setup analytics for, if not provided the user
  1737  	// id associated with the project is used. optional
  1738  	UserId string `json:"userId,omitempty"`
  1739  	// ForceSendFields is a list of field names (e.g. "UserId") to unconditionally
  1740  	// include in API requests. By default, fields with empty or default values are
  1741  	// omitted from API requests. See
  1742  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1743  	// details.
  1744  	ForceSendFields []string `json:"-"`
  1745  	// NullFields is a list of field names (e.g. "UserId") to include in API
  1746  	// requests with the JSON null value. By default, fields with empty values are
  1747  	// omitted from API requests. See
  1748  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1749  	NullFields []string `json:"-"`
  1750  }
  1751  
  1752  func (s *SasPortalSetupSasAnalyticsRequest) MarshalJSON() ([]byte, error) {
  1753  	type NoMethod SasPortalSetupSasAnalyticsRequest
  1754  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1755  }
  1756  
  1757  // SasPortalSetupSasAnalyticsResponse: Response returned by the long running
  1758  // operation for the SetupSasAnalytics rpc.
  1759  type SasPortalSetupSasAnalyticsResponse struct {
  1760  }
  1761  
  1762  // SasPortalSignDeviceRequest: Request for SignDevice.
  1763  type SasPortalSignDeviceRequest struct {
  1764  	// Device: Required. The device to sign. The device fields name, fcc_id and
  1765  	// serial_number must be set. The user_id field must be set.
  1766  	Device *SasPortalDevice `json:"device,omitempty"`
  1767  	// ForceSendFields is a list of field names (e.g. "Device") to unconditionally
  1768  	// include in API requests. By default, fields with empty or default values are
  1769  	// omitted from API requests. See
  1770  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1771  	// details.
  1772  	ForceSendFields []string `json:"-"`
  1773  	// NullFields is a list of field names (e.g. "Device") to include in API
  1774  	// requests with the JSON null value. By default, fields with empty values are
  1775  	// omitted from API requests. See
  1776  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1777  	NullFields []string `json:"-"`
  1778  }
  1779  
  1780  func (s *SasPortalSignDeviceRequest) MarshalJSON() ([]byte, error) {
  1781  	type NoMethod SasPortalSignDeviceRequest
  1782  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1783  }
  1784  
  1785  // SasPortalStatus: The `Status` type defines a logical error model that is
  1786  // suitable for different programming environments, including REST APIs and RPC
  1787  // APIs. It is used by gRPC (https://github.com/grpc). Each `Status` message
  1788  // contains three pieces of data: error code, error message, and error details.
  1789  // You can find out more about this error model and how to work with it in the
  1790  // API Design Guide (https://cloud.google.com/apis/design/errors).
  1791  type SasPortalStatus struct {
  1792  	// Code: The status code, which should be an enum value of google.rpc.Code.
  1793  	Code int64 `json:"code,omitempty"`
  1794  	// Details: A list of messages that carry the error details. There is a common
  1795  	// set of message types for APIs to use.
  1796  	Details []googleapi.RawMessage `json:"details,omitempty"`
  1797  	// Message: A developer-facing error message, which should be in English. Any
  1798  	// user-facing error message should be localized and sent in the
  1799  	// google.rpc.Status.details field, or localized by the client.
  1800  	Message string `json:"message,omitempty"`
  1801  	// ForceSendFields is a list of field names (e.g. "Code") to unconditionally
  1802  	// include in API requests. By default, fields with empty or default values are
  1803  	// omitted from API requests. See
  1804  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1805  	// details.
  1806  	ForceSendFields []string `json:"-"`
  1807  	// NullFields is a list of field names (e.g. "Code") to include in API requests
  1808  	// with the JSON null value. By default, fields with empty values are omitted
  1809  	// from API requests. See
  1810  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1811  	NullFields []string `json:"-"`
  1812  }
  1813  
  1814  func (s *SasPortalStatus) MarshalJSON() ([]byte, error) {
  1815  	type NoMethod SasPortalStatus
  1816  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1817  }
  1818  
  1819  // SasPortalTestPermissionsRequest: Request message for `TestPermissions`
  1820  // method.
  1821  type SasPortalTestPermissionsRequest struct {
  1822  	// Permissions: The set of permissions to check for the `resource`.
  1823  	Permissions []string `json:"permissions,omitempty"`
  1824  	// Resource: Required. The resource for which the permissions are being
  1825  	// requested.
  1826  	Resource string `json:"resource,omitempty"`
  1827  	// ForceSendFields is a list of field names (e.g. "Permissions") to
  1828  	// unconditionally include in API requests. By default, fields with empty or
  1829  	// default values are omitted from API requests. See
  1830  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1831  	// details.
  1832  	ForceSendFields []string `json:"-"`
  1833  	// NullFields is a list of field names (e.g. "Permissions") to include in API
  1834  	// requests with the JSON null value. By default, fields with empty values are
  1835  	// omitted from API requests. See
  1836  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1837  	NullFields []string `json:"-"`
  1838  }
  1839  
  1840  func (s *SasPortalTestPermissionsRequest) MarshalJSON() ([]byte, error) {
  1841  	type NoMethod SasPortalTestPermissionsRequest
  1842  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1843  }
  1844  
  1845  // SasPortalTestPermissionsResponse: Response message for `TestPermissions`
  1846  // method.
  1847  type SasPortalTestPermissionsResponse struct {
  1848  	// Permissions: A set of permissions that the caller is allowed.
  1849  	Permissions []string `json:"permissions,omitempty"`
  1850  
  1851  	// ServerResponse contains the HTTP response code and headers from the server.
  1852  	googleapi.ServerResponse `json:"-"`
  1853  	// ForceSendFields is a list of field names (e.g. "Permissions") to
  1854  	// unconditionally include in API requests. By default, fields with empty or
  1855  	// default values are omitted from API requests. See
  1856  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1857  	// details.
  1858  	ForceSendFields []string `json:"-"`
  1859  	// NullFields is a list of field names (e.g. "Permissions") to include in API
  1860  	// requests with the JSON null value. By default, fields with empty values are
  1861  	// omitted from API requests. See
  1862  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1863  	NullFields []string `json:"-"`
  1864  }
  1865  
  1866  func (s *SasPortalTestPermissionsResponse) MarshalJSON() ([]byte, error) {
  1867  	type NoMethod SasPortalTestPermissionsResponse
  1868  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1869  }
  1870  
  1871  // SasPortalUpdateSignedDeviceRequest: Request for UpdateSignedDevice.
  1872  type SasPortalUpdateSignedDeviceRequest struct {
  1873  	// EncodedDevice: Required. The JSON Web Token signed using a CPI private key.
  1874  	// Payload must be the JSON encoding of the device. The user_id field must be
  1875  	// set.
  1876  	EncodedDevice string `json:"encodedDevice,omitempty"`
  1877  	// InstallerId: Required. Unique installer ID (CPI ID) from the Certified
  1878  	// Professional Installers database.
  1879  	InstallerId string `json:"installerId,omitempty"`
  1880  	// ForceSendFields is a list of field names (e.g. "EncodedDevice") to
  1881  	// unconditionally include in API requests. By default, fields with empty or
  1882  	// default values are omitted from API requests. See
  1883  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1884  	// details.
  1885  	ForceSendFields []string `json:"-"`
  1886  	// NullFields is a list of field names (e.g. "EncodedDevice") to include in API
  1887  	// requests with the JSON null value. By default, fields with empty values are
  1888  	// omitted from API requests. See
  1889  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1890  	NullFields []string `json:"-"`
  1891  }
  1892  
  1893  func (s *SasPortalUpdateSignedDeviceRequest) MarshalJSON() ([]byte, error) {
  1894  	type NoMethod SasPortalUpdateSignedDeviceRequest
  1895  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1896  }
  1897  
  1898  // SasPortalValidateInstallerRequest: Request for ValidateInstaller.
  1899  type SasPortalValidateInstallerRequest struct {
  1900  	// EncodedSecret: Required. JSON Web Token signed using a CPI private key.
  1901  	// Payload must include a "secret" claim whose value is the secret.
  1902  	EncodedSecret string `json:"encodedSecret,omitempty"`
  1903  	// InstallerId: Required. Unique installer id (CPI ID) from the Certified
  1904  	// Professional Installers database.
  1905  	InstallerId string `json:"installerId,omitempty"`
  1906  	// Secret: Required. Secret returned by the GenerateSecret.
  1907  	Secret string `json:"secret,omitempty"`
  1908  	// ForceSendFields is a list of field names (e.g. "EncodedSecret") to
  1909  	// unconditionally include in API requests. By default, fields with empty or
  1910  	// default values are omitted from API requests. See
  1911  	// https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more
  1912  	// details.
  1913  	ForceSendFields []string `json:"-"`
  1914  	// NullFields is a list of field names (e.g. "EncodedSecret") to include in API
  1915  	// requests with the JSON null value. By default, fields with empty values are
  1916  	// omitted from API requests. See
  1917  	// https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details.
  1918  	NullFields []string `json:"-"`
  1919  }
  1920  
  1921  func (s *SasPortalValidateInstallerRequest) MarshalJSON() ([]byte, error) {
  1922  	type NoMethod SasPortalValidateInstallerRequest
  1923  	return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields)
  1924  }
  1925  
  1926  // SasPortalValidateInstallerResponse: Response for ValidateInstaller.
  1927  type SasPortalValidateInstallerResponse struct {
  1928  	// ServerResponse contains the HTTP response code and headers from the server.
  1929  	googleapi.ServerResponse `json:"-"`
  1930  }
  1931  
  1932  type CustomersGetCall struct {
  1933  	s            *Service
  1934  	name         string
  1935  	urlParams_   gensupport.URLParams
  1936  	ifNoneMatch_ string
  1937  	ctx_         context.Context
  1938  	header_      http.Header
  1939  }
  1940  
  1941  // Get: Returns a requested customer.
  1942  //
  1943  // - name: The name of the customer.
  1944  func (r *CustomersService) Get(name string) *CustomersGetCall {
  1945  	c := &CustomersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1946  	c.name = name
  1947  	return c
  1948  }
  1949  
  1950  // Fields allows partial responses to be retrieved. See
  1951  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  1952  // details.
  1953  func (c *CustomersGetCall) Fields(s ...googleapi.Field) *CustomersGetCall {
  1954  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1955  	return c
  1956  }
  1957  
  1958  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  1959  // object's ETag matches the given value. This is useful for getting updates
  1960  // only after the object has changed since the last request.
  1961  func (c *CustomersGetCall) IfNoneMatch(entityTag string) *CustomersGetCall {
  1962  	c.ifNoneMatch_ = entityTag
  1963  	return c
  1964  }
  1965  
  1966  // Context sets the context to be used in this call's Do method.
  1967  func (c *CustomersGetCall) Context(ctx context.Context) *CustomersGetCall {
  1968  	c.ctx_ = ctx
  1969  	return c
  1970  }
  1971  
  1972  // Header returns a http.Header that can be modified by the caller to add
  1973  // headers to the request.
  1974  func (c *CustomersGetCall) Header() http.Header {
  1975  	if c.header_ == nil {
  1976  		c.header_ = make(http.Header)
  1977  	}
  1978  	return c.header_
  1979  }
  1980  
  1981  func (c *CustomersGetCall) doRequest(alt string) (*http.Response, error) {
  1982  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  1983  	if c.ifNoneMatch_ != "" {
  1984  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1985  	}
  1986  	var body io.Reader = nil
  1987  	c.urlParams_.Set("alt", alt)
  1988  	c.urlParams_.Set("prettyPrint", "false")
  1989  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  1990  	urls += "?" + c.urlParams_.Encode()
  1991  	req, err := http.NewRequest("GET", urls, body)
  1992  	if err != nil {
  1993  		return nil, err
  1994  	}
  1995  	req.Header = reqHeaders
  1996  	googleapi.Expand(req.URL, map[string]string{
  1997  		"name": c.name,
  1998  	})
  1999  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2000  }
  2001  
  2002  // Do executes the "sasportal.customers.get" call.
  2003  // Any non-2xx status code is an error. Response headers are in either
  2004  // *SasPortalCustomer.ServerResponse.Header or (if a response was returned at
  2005  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2006  // check whether the returned error was because http.StatusNotModified was
  2007  // returned.
  2008  func (c *CustomersGetCall) Do(opts ...googleapi.CallOption) (*SasPortalCustomer, error) {
  2009  	gensupport.SetOptions(c.urlParams_, opts...)
  2010  	res, err := c.doRequest("json")
  2011  	if res != nil && res.StatusCode == http.StatusNotModified {
  2012  		if res.Body != nil {
  2013  			res.Body.Close()
  2014  		}
  2015  		return nil, gensupport.WrapError(&googleapi.Error{
  2016  			Code:   res.StatusCode,
  2017  			Header: res.Header,
  2018  		})
  2019  	}
  2020  	if err != nil {
  2021  		return nil, err
  2022  	}
  2023  	defer googleapi.CloseBody(res)
  2024  	if err := googleapi.CheckResponse(res); err != nil {
  2025  		return nil, gensupport.WrapError(err)
  2026  	}
  2027  	ret := &SasPortalCustomer{
  2028  		ServerResponse: googleapi.ServerResponse{
  2029  			Header:         res.Header,
  2030  			HTTPStatusCode: res.StatusCode,
  2031  		},
  2032  	}
  2033  	target := &ret
  2034  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2035  		return nil, err
  2036  	}
  2037  	return ret, nil
  2038  }
  2039  
  2040  type CustomersListCall struct {
  2041  	s            *Service
  2042  	urlParams_   gensupport.URLParams
  2043  	ifNoneMatch_ string
  2044  	ctx_         context.Context
  2045  	header_      http.Header
  2046  }
  2047  
  2048  // List: Returns a list of requested customers.
  2049  func (r *CustomersService) List() *CustomersListCall {
  2050  	c := &CustomersListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2051  	return c
  2052  }
  2053  
  2054  // PageSize sets the optional parameter "pageSize": The maximum number of
  2055  // customers to return in the response.
  2056  func (c *CustomersListCall) PageSize(pageSize int64) *CustomersListCall {
  2057  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  2058  	return c
  2059  }
  2060  
  2061  // PageToken sets the optional parameter "pageToken": A pagination token
  2062  // returned from a previous call to ListCustomers that indicates where this
  2063  // listing should continue from.
  2064  func (c *CustomersListCall) PageToken(pageToken string) *CustomersListCall {
  2065  	c.urlParams_.Set("pageToken", pageToken)
  2066  	return c
  2067  }
  2068  
  2069  // Fields allows partial responses to be retrieved. See
  2070  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2071  // details.
  2072  func (c *CustomersListCall) Fields(s ...googleapi.Field) *CustomersListCall {
  2073  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2074  	return c
  2075  }
  2076  
  2077  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  2078  // object's ETag matches the given value. This is useful for getting updates
  2079  // only after the object has changed since the last request.
  2080  func (c *CustomersListCall) IfNoneMatch(entityTag string) *CustomersListCall {
  2081  	c.ifNoneMatch_ = entityTag
  2082  	return c
  2083  }
  2084  
  2085  // Context sets the context to be used in this call's Do method.
  2086  func (c *CustomersListCall) Context(ctx context.Context) *CustomersListCall {
  2087  	c.ctx_ = ctx
  2088  	return c
  2089  }
  2090  
  2091  // Header returns a http.Header that can be modified by the caller to add
  2092  // headers to the request.
  2093  func (c *CustomersListCall) Header() http.Header {
  2094  	if c.header_ == nil {
  2095  		c.header_ = make(http.Header)
  2096  	}
  2097  	return c.header_
  2098  }
  2099  
  2100  func (c *CustomersListCall) doRequest(alt string) (*http.Response, error) {
  2101  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2102  	if c.ifNoneMatch_ != "" {
  2103  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2104  	}
  2105  	var body io.Reader = nil
  2106  	c.urlParams_.Set("alt", alt)
  2107  	c.urlParams_.Set("prettyPrint", "false")
  2108  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers")
  2109  	urls += "?" + c.urlParams_.Encode()
  2110  	req, err := http.NewRequest("GET", urls, body)
  2111  	if err != nil {
  2112  		return nil, err
  2113  	}
  2114  	req.Header = reqHeaders
  2115  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2116  }
  2117  
  2118  // Do executes the "sasportal.customers.list" call.
  2119  // Any non-2xx status code is an error. Response headers are in either
  2120  // *SasPortalListCustomersResponse.ServerResponse.Header or (if a response was
  2121  // returned at all) in error.(*googleapi.Error).Header. Use
  2122  // googleapi.IsNotModified to check whether the returned error was because
  2123  // http.StatusNotModified was returned.
  2124  func (c *CustomersListCall) Do(opts ...googleapi.CallOption) (*SasPortalListCustomersResponse, error) {
  2125  	gensupport.SetOptions(c.urlParams_, opts...)
  2126  	res, err := c.doRequest("json")
  2127  	if res != nil && res.StatusCode == http.StatusNotModified {
  2128  		if res.Body != nil {
  2129  			res.Body.Close()
  2130  		}
  2131  		return nil, gensupport.WrapError(&googleapi.Error{
  2132  			Code:   res.StatusCode,
  2133  			Header: res.Header,
  2134  		})
  2135  	}
  2136  	if err != nil {
  2137  		return nil, err
  2138  	}
  2139  	defer googleapi.CloseBody(res)
  2140  	if err := googleapi.CheckResponse(res); err != nil {
  2141  		return nil, gensupport.WrapError(err)
  2142  	}
  2143  	ret := &SasPortalListCustomersResponse{
  2144  		ServerResponse: googleapi.ServerResponse{
  2145  			Header:         res.Header,
  2146  			HTTPStatusCode: res.StatusCode,
  2147  		},
  2148  	}
  2149  	target := &ret
  2150  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2151  		return nil, err
  2152  	}
  2153  	return ret, nil
  2154  }
  2155  
  2156  // Pages invokes f for each page of results.
  2157  // A non-nil error returned from f will halt the iteration.
  2158  // The provided context supersedes any context provided to the Context method.
  2159  func (c *CustomersListCall) Pages(ctx context.Context, f func(*SasPortalListCustomersResponse) error) error {
  2160  	c.ctx_ = ctx
  2161  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  2162  	for {
  2163  		x, err := c.Do()
  2164  		if err != nil {
  2165  			return err
  2166  		}
  2167  		if err := f(x); err != nil {
  2168  			return err
  2169  		}
  2170  		if x.NextPageToken == "" {
  2171  			return nil
  2172  		}
  2173  		c.PageToken(x.NextPageToken)
  2174  	}
  2175  }
  2176  
  2177  type CustomersListGcpProjectDeploymentsCall struct {
  2178  	s            *Service
  2179  	urlParams_   gensupport.URLParams
  2180  	ifNoneMatch_ string
  2181  	ctx_         context.Context
  2182  	header_      http.Header
  2183  }
  2184  
  2185  // ListGcpProjectDeployments: Returns a list of SAS deployments associated with
  2186  // current GCP project. Includes whether SAS analytics has been enabled or not.
  2187  func (r *CustomersService) ListGcpProjectDeployments() *CustomersListGcpProjectDeploymentsCall {
  2188  	c := &CustomersListGcpProjectDeploymentsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2189  	return c
  2190  }
  2191  
  2192  // Fields allows partial responses to be retrieved. See
  2193  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2194  // details.
  2195  func (c *CustomersListGcpProjectDeploymentsCall) Fields(s ...googleapi.Field) *CustomersListGcpProjectDeploymentsCall {
  2196  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2197  	return c
  2198  }
  2199  
  2200  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  2201  // object's ETag matches the given value. This is useful for getting updates
  2202  // only after the object has changed since the last request.
  2203  func (c *CustomersListGcpProjectDeploymentsCall) IfNoneMatch(entityTag string) *CustomersListGcpProjectDeploymentsCall {
  2204  	c.ifNoneMatch_ = entityTag
  2205  	return c
  2206  }
  2207  
  2208  // Context sets the context to be used in this call's Do method.
  2209  func (c *CustomersListGcpProjectDeploymentsCall) Context(ctx context.Context) *CustomersListGcpProjectDeploymentsCall {
  2210  	c.ctx_ = ctx
  2211  	return c
  2212  }
  2213  
  2214  // Header returns a http.Header that can be modified by the caller to add
  2215  // headers to the request.
  2216  func (c *CustomersListGcpProjectDeploymentsCall) Header() http.Header {
  2217  	if c.header_ == nil {
  2218  		c.header_ = make(http.Header)
  2219  	}
  2220  	return c.header_
  2221  }
  2222  
  2223  func (c *CustomersListGcpProjectDeploymentsCall) doRequest(alt string) (*http.Response, error) {
  2224  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2225  	if c.ifNoneMatch_ != "" {
  2226  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2227  	}
  2228  	var body io.Reader = nil
  2229  	c.urlParams_.Set("alt", alt)
  2230  	c.urlParams_.Set("prettyPrint", "false")
  2231  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers:listGcpProjectDeployments")
  2232  	urls += "?" + c.urlParams_.Encode()
  2233  	req, err := http.NewRequest("GET", urls, body)
  2234  	if err != nil {
  2235  		return nil, err
  2236  	}
  2237  	req.Header = reqHeaders
  2238  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2239  }
  2240  
  2241  // Do executes the "sasportal.customers.listGcpProjectDeployments" call.
  2242  // Any non-2xx status code is an error. Response headers are in either
  2243  // *SasPortalListGcpProjectDeploymentsResponse.ServerResponse.Header or (if a
  2244  // response was returned at all) in error.(*googleapi.Error).Header. Use
  2245  // googleapi.IsNotModified to check whether the returned error was because
  2246  // http.StatusNotModified was returned.
  2247  func (c *CustomersListGcpProjectDeploymentsCall) Do(opts ...googleapi.CallOption) (*SasPortalListGcpProjectDeploymentsResponse, error) {
  2248  	gensupport.SetOptions(c.urlParams_, opts...)
  2249  	res, err := c.doRequest("json")
  2250  	if res != nil && res.StatusCode == http.StatusNotModified {
  2251  		if res.Body != nil {
  2252  			res.Body.Close()
  2253  		}
  2254  		return nil, gensupport.WrapError(&googleapi.Error{
  2255  			Code:   res.StatusCode,
  2256  			Header: res.Header,
  2257  		})
  2258  	}
  2259  	if err != nil {
  2260  		return nil, err
  2261  	}
  2262  	defer googleapi.CloseBody(res)
  2263  	if err := googleapi.CheckResponse(res); err != nil {
  2264  		return nil, gensupport.WrapError(err)
  2265  	}
  2266  	ret := &SasPortalListGcpProjectDeploymentsResponse{
  2267  		ServerResponse: googleapi.ServerResponse{
  2268  			Header:         res.Header,
  2269  			HTTPStatusCode: res.StatusCode,
  2270  		},
  2271  	}
  2272  	target := &ret
  2273  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2274  		return nil, err
  2275  	}
  2276  	return ret, nil
  2277  }
  2278  
  2279  type CustomersListLegacyOrganizationsCall struct {
  2280  	s            *Service
  2281  	urlParams_   gensupport.URLParams
  2282  	ifNoneMatch_ string
  2283  	ctx_         context.Context
  2284  	header_      http.Header
  2285  }
  2286  
  2287  // ListLegacyOrganizations: Returns a list of legacy organizations.
  2288  func (r *CustomersService) ListLegacyOrganizations() *CustomersListLegacyOrganizationsCall {
  2289  	c := &CustomersListLegacyOrganizationsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2290  	return c
  2291  }
  2292  
  2293  // Fields allows partial responses to be retrieved. See
  2294  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2295  // details.
  2296  func (c *CustomersListLegacyOrganizationsCall) Fields(s ...googleapi.Field) *CustomersListLegacyOrganizationsCall {
  2297  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2298  	return c
  2299  }
  2300  
  2301  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  2302  // object's ETag matches the given value. This is useful for getting updates
  2303  // only after the object has changed since the last request.
  2304  func (c *CustomersListLegacyOrganizationsCall) IfNoneMatch(entityTag string) *CustomersListLegacyOrganizationsCall {
  2305  	c.ifNoneMatch_ = entityTag
  2306  	return c
  2307  }
  2308  
  2309  // Context sets the context to be used in this call's Do method.
  2310  func (c *CustomersListLegacyOrganizationsCall) Context(ctx context.Context) *CustomersListLegacyOrganizationsCall {
  2311  	c.ctx_ = ctx
  2312  	return c
  2313  }
  2314  
  2315  // Header returns a http.Header that can be modified by the caller to add
  2316  // headers to the request.
  2317  func (c *CustomersListLegacyOrganizationsCall) Header() http.Header {
  2318  	if c.header_ == nil {
  2319  		c.header_ = make(http.Header)
  2320  	}
  2321  	return c.header_
  2322  }
  2323  
  2324  func (c *CustomersListLegacyOrganizationsCall) doRequest(alt string) (*http.Response, error) {
  2325  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2326  	if c.ifNoneMatch_ != "" {
  2327  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2328  	}
  2329  	var body io.Reader = nil
  2330  	c.urlParams_.Set("alt", alt)
  2331  	c.urlParams_.Set("prettyPrint", "false")
  2332  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers:listLegacyOrganizations")
  2333  	urls += "?" + c.urlParams_.Encode()
  2334  	req, err := http.NewRequest("GET", urls, body)
  2335  	if err != nil {
  2336  		return nil, err
  2337  	}
  2338  	req.Header = reqHeaders
  2339  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2340  }
  2341  
  2342  // Do executes the "sasportal.customers.listLegacyOrganizations" call.
  2343  // Any non-2xx status code is an error. Response headers are in either
  2344  // *SasPortalListLegacyOrganizationsResponse.ServerResponse.Header or (if a
  2345  // response was returned at all) in error.(*googleapi.Error).Header. Use
  2346  // googleapi.IsNotModified to check whether the returned error was because
  2347  // http.StatusNotModified was returned.
  2348  func (c *CustomersListLegacyOrganizationsCall) Do(opts ...googleapi.CallOption) (*SasPortalListLegacyOrganizationsResponse, error) {
  2349  	gensupport.SetOptions(c.urlParams_, opts...)
  2350  	res, err := c.doRequest("json")
  2351  	if res != nil && res.StatusCode == http.StatusNotModified {
  2352  		if res.Body != nil {
  2353  			res.Body.Close()
  2354  		}
  2355  		return nil, gensupport.WrapError(&googleapi.Error{
  2356  			Code:   res.StatusCode,
  2357  			Header: res.Header,
  2358  		})
  2359  	}
  2360  	if err != nil {
  2361  		return nil, err
  2362  	}
  2363  	defer googleapi.CloseBody(res)
  2364  	if err := googleapi.CheckResponse(res); err != nil {
  2365  		return nil, gensupport.WrapError(err)
  2366  	}
  2367  	ret := &SasPortalListLegacyOrganizationsResponse{
  2368  		ServerResponse: googleapi.ServerResponse{
  2369  			Header:         res.Header,
  2370  			HTTPStatusCode: res.StatusCode,
  2371  		},
  2372  	}
  2373  	target := &ret
  2374  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2375  		return nil, err
  2376  	}
  2377  	return ret, nil
  2378  }
  2379  
  2380  type CustomersMigrateOrganizationCall struct {
  2381  	s                                   *Service
  2382  	sasportalmigrateorganizationrequest *SasPortalMigrateOrganizationRequest
  2383  	urlParams_                          gensupport.URLParams
  2384  	ctx_                                context.Context
  2385  	header_                             http.Header
  2386  }
  2387  
  2388  // MigrateOrganization: Migrates a SAS organization to the cloud. This will
  2389  // create GCP projects for each deployment and associate them. The SAS
  2390  // Organization is linked to the gcp project that called the command.
  2391  // go/sas-legacy-customer-migration
  2392  func (r *CustomersService) MigrateOrganization(sasportalmigrateorganizationrequest *SasPortalMigrateOrganizationRequest) *CustomersMigrateOrganizationCall {
  2393  	c := &CustomersMigrateOrganizationCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2394  	c.sasportalmigrateorganizationrequest = sasportalmigrateorganizationrequest
  2395  	return c
  2396  }
  2397  
  2398  // Fields allows partial responses to be retrieved. See
  2399  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2400  // details.
  2401  func (c *CustomersMigrateOrganizationCall) Fields(s ...googleapi.Field) *CustomersMigrateOrganizationCall {
  2402  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2403  	return c
  2404  }
  2405  
  2406  // Context sets the context to be used in this call's Do method.
  2407  func (c *CustomersMigrateOrganizationCall) Context(ctx context.Context) *CustomersMigrateOrganizationCall {
  2408  	c.ctx_ = ctx
  2409  	return c
  2410  }
  2411  
  2412  // Header returns a http.Header that can be modified by the caller to add
  2413  // headers to the request.
  2414  func (c *CustomersMigrateOrganizationCall) Header() http.Header {
  2415  	if c.header_ == nil {
  2416  		c.header_ = make(http.Header)
  2417  	}
  2418  	return c.header_
  2419  }
  2420  
  2421  func (c *CustomersMigrateOrganizationCall) doRequest(alt string) (*http.Response, error) {
  2422  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2423  	var body io.Reader = nil
  2424  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmigrateorganizationrequest)
  2425  	if err != nil {
  2426  		return nil, err
  2427  	}
  2428  	c.urlParams_.Set("alt", alt)
  2429  	c.urlParams_.Set("prettyPrint", "false")
  2430  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers:migrateOrganization")
  2431  	urls += "?" + c.urlParams_.Encode()
  2432  	req, err := http.NewRequest("POST", urls, body)
  2433  	if err != nil {
  2434  		return nil, err
  2435  	}
  2436  	req.Header = reqHeaders
  2437  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2438  }
  2439  
  2440  // Do executes the "sasportal.customers.migrateOrganization" call.
  2441  // Any non-2xx status code is an error. Response headers are in either
  2442  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  2443  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2444  // check whether the returned error was because http.StatusNotModified was
  2445  // returned.
  2446  func (c *CustomersMigrateOrganizationCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  2447  	gensupport.SetOptions(c.urlParams_, opts...)
  2448  	res, err := c.doRequest("json")
  2449  	if res != nil && res.StatusCode == http.StatusNotModified {
  2450  		if res.Body != nil {
  2451  			res.Body.Close()
  2452  		}
  2453  		return nil, gensupport.WrapError(&googleapi.Error{
  2454  			Code:   res.StatusCode,
  2455  			Header: res.Header,
  2456  		})
  2457  	}
  2458  	if err != nil {
  2459  		return nil, err
  2460  	}
  2461  	defer googleapi.CloseBody(res)
  2462  	if err := googleapi.CheckResponse(res); err != nil {
  2463  		return nil, gensupport.WrapError(err)
  2464  	}
  2465  	ret := &SasPortalOperation{
  2466  		ServerResponse: googleapi.ServerResponse{
  2467  			Header:         res.Header,
  2468  			HTTPStatusCode: res.StatusCode,
  2469  		},
  2470  	}
  2471  	target := &ret
  2472  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2473  		return nil, err
  2474  	}
  2475  	return ret, nil
  2476  }
  2477  
  2478  type CustomersPatchCall struct {
  2479  	s                 *Service
  2480  	name              string
  2481  	sasportalcustomer *SasPortalCustomer
  2482  	urlParams_        gensupport.URLParams
  2483  	ctx_              context.Context
  2484  	header_           http.Header
  2485  }
  2486  
  2487  // Patch: Updates an existing customer.
  2488  //
  2489  // - name: Output only. Resource name of the customer.
  2490  func (r *CustomersService) Patch(name string, sasportalcustomer *SasPortalCustomer) *CustomersPatchCall {
  2491  	c := &CustomersPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2492  	c.name = name
  2493  	c.sasportalcustomer = sasportalcustomer
  2494  	return c
  2495  }
  2496  
  2497  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  2498  func (c *CustomersPatchCall) UpdateMask(updateMask string) *CustomersPatchCall {
  2499  	c.urlParams_.Set("updateMask", updateMask)
  2500  	return c
  2501  }
  2502  
  2503  // Fields allows partial responses to be retrieved. See
  2504  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2505  // details.
  2506  func (c *CustomersPatchCall) Fields(s ...googleapi.Field) *CustomersPatchCall {
  2507  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2508  	return c
  2509  }
  2510  
  2511  // Context sets the context to be used in this call's Do method.
  2512  func (c *CustomersPatchCall) Context(ctx context.Context) *CustomersPatchCall {
  2513  	c.ctx_ = ctx
  2514  	return c
  2515  }
  2516  
  2517  // Header returns a http.Header that can be modified by the caller to add
  2518  // headers to the request.
  2519  func (c *CustomersPatchCall) Header() http.Header {
  2520  	if c.header_ == nil {
  2521  		c.header_ = make(http.Header)
  2522  	}
  2523  	return c.header_
  2524  }
  2525  
  2526  func (c *CustomersPatchCall) doRequest(alt string) (*http.Response, error) {
  2527  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2528  	var body io.Reader = nil
  2529  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcustomer)
  2530  	if err != nil {
  2531  		return nil, err
  2532  	}
  2533  	c.urlParams_.Set("alt", alt)
  2534  	c.urlParams_.Set("prettyPrint", "false")
  2535  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  2536  	urls += "?" + c.urlParams_.Encode()
  2537  	req, err := http.NewRequest("PATCH", urls, body)
  2538  	if err != nil {
  2539  		return nil, err
  2540  	}
  2541  	req.Header = reqHeaders
  2542  	googleapi.Expand(req.URL, map[string]string{
  2543  		"name": c.name,
  2544  	})
  2545  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2546  }
  2547  
  2548  // Do executes the "sasportal.customers.patch" call.
  2549  // Any non-2xx status code is an error. Response headers are in either
  2550  // *SasPortalCustomer.ServerResponse.Header or (if a response was returned at
  2551  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2552  // check whether the returned error was because http.StatusNotModified was
  2553  // returned.
  2554  func (c *CustomersPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalCustomer, error) {
  2555  	gensupport.SetOptions(c.urlParams_, opts...)
  2556  	res, err := c.doRequest("json")
  2557  	if res != nil && res.StatusCode == http.StatusNotModified {
  2558  		if res.Body != nil {
  2559  			res.Body.Close()
  2560  		}
  2561  		return nil, gensupport.WrapError(&googleapi.Error{
  2562  			Code:   res.StatusCode,
  2563  			Header: res.Header,
  2564  		})
  2565  	}
  2566  	if err != nil {
  2567  		return nil, err
  2568  	}
  2569  	defer googleapi.CloseBody(res)
  2570  	if err := googleapi.CheckResponse(res); err != nil {
  2571  		return nil, gensupport.WrapError(err)
  2572  	}
  2573  	ret := &SasPortalCustomer{
  2574  		ServerResponse: googleapi.ServerResponse{
  2575  			Header:         res.Header,
  2576  			HTTPStatusCode: res.StatusCode,
  2577  		},
  2578  	}
  2579  	target := &ret
  2580  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2581  		return nil, err
  2582  	}
  2583  	return ret, nil
  2584  }
  2585  
  2586  type CustomersProvisionDeploymentCall struct {
  2587  	s                                   *Service
  2588  	sasportalprovisiondeploymentrequest *SasPortalProvisionDeploymentRequest
  2589  	urlParams_                          gensupport.URLParams
  2590  	ctx_                                context.Context
  2591  	header_                             http.Header
  2592  }
  2593  
  2594  // ProvisionDeployment: Creates a new SAS deployment through the GCP workflow.
  2595  // Creates a SAS organization if an organization match is not found.
  2596  func (r *CustomersService) ProvisionDeployment(sasportalprovisiondeploymentrequest *SasPortalProvisionDeploymentRequest) *CustomersProvisionDeploymentCall {
  2597  	c := &CustomersProvisionDeploymentCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2598  	c.sasportalprovisiondeploymentrequest = sasportalprovisiondeploymentrequest
  2599  	return c
  2600  }
  2601  
  2602  // Fields allows partial responses to be retrieved. See
  2603  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2604  // details.
  2605  func (c *CustomersProvisionDeploymentCall) Fields(s ...googleapi.Field) *CustomersProvisionDeploymentCall {
  2606  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2607  	return c
  2608  }
  2609  
  2610  // Context sets the context to be used in this call's Do method.
  2611  func (c *CustomersProvisionDeploymentCall) Context(ctx context.Context) *CustomersProvisionDeploymentCall {
  2612  	c.ctx_ = ctx
  2613  	return c
  2614  }
  2615  
  2616  // Header returns a http.Header that can be modified by the caller to add
  2617  // headers to the request.
  2618  func (c *CustomersProvisionDeploymentCall) Header() http.Header {
  2619  	if c.header_ == nil {
  2620  		c.header_ = make(http.Header)
  2621  	}
  2622  	return c.header_
  2623  }
  2624  
  2625  func (c *CustomersProvisionDeploymentCall) doRequest(alt string) (*http.Response, error) {
  2626  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2627  	var body io.Reader = nil
  2628  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalprovisiondeploymentrequest)
  2629  	if err != nil {
  2630  		return nil, err
  2631  	}
  2632  	c.urlParams_.Set("alt", alt)
  2633  	c.urlParams_.Set("prettyPrint", "false")
  2634  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers:provisionDeployment")
  2635  	urls += "?" + c.urlParams_.Encode()
  2636  	req, err := http.NewRequest("POST", urls, body)
  2637  	if err != nil {
  2638  		return nil, err
  2639  	}
  2640  	req.Header = reqHeaders
  2641  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2642  }
  2643  
  2644  // Do executes the "sasportal.customers.provisionDeployment" call.
  2645  // Any non-2xx status code is an error. Response headers are in either
  2646  // *SasPortalProvisionDeploymentResponse.ServerResponse.Header or (if a
  2647  // response was returned at all) in error.(*googleapi.Error).Header. Use
  2648  // googleapi.IsNotModified to check whether the returned error was because
  2649  // http.StatusNotModified was returned.
  2650  func (c *CustomersProvisionDeploymentCall) Do(opts ...googleapi.CallOption) (*SasPortalProvisionDeploymentResponse, error) {
  2651  	gensupport.SetOptions(c.urlParams_, opts...)
  2652  	res, err := c.doRequest("json")
  2653  	if res != nil && res.StatusCode == http.StatusNotModified {
  2654  		if res.Body != nil {
  2655  			res.Body.Close()
  2656  		}
  2657  		return nil, gensupport.WrapError(&googleapi.Error{
  2658  			Code:   res.StatusCode,
  2659  			Header: res.Header,
  2660  		})
  2661  	}
  2662  	if err != nil {
  2663  		return nil, err
  2664  	}
  2665  	defer googleapi.CloseBody(res)
  2666  	if err := googleapi.CheckResponse(res); err != nil {
  2667  		return nil, gensupport.WrapError(err)
  2668  	}
  2669  	ret := &SasPortalProvisionDeploymentResponse{
  2670  		ServerResponse: googleapi.ServerResponse{
  2671  			Header:         res.Header,
  2672  			HTTPStatusCode: res.StatusCode,
  2673  		},
  2674  	}
  2675  	target := &ret
  2676  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2677  		return nil, err
  2678  	}
  2679  	return ret, nil
  2680  }
  2681  
  2682  type CustomersSetupSasAnalyticsCall struct {
  2683  	s                                 *Service
  2684  	sasportalsetupsasanalyticsrequest *SasPortalSetupSasAnalyticsRequest
  2685  	urlParams_                        gensupport.URLParams
  2686  	ctx_                              context.Context
  2687  	header_                           http.Header
  2688  }
  2689  
  2690  // SetupSasAnalytics: Setups the a GCP Project to receive SAS Analytics
  2691  // messages via GCP Pub/Sub with a subscription to BigQuery. All the Pub/Sub
  2692  // topics and BigQuery tables are created automatically as part of this
  2693  // service.
  2694  func (r *CustomersService) SetupSasAnalytics(sasportalsetupsasanalyticsrequest *SasPortalSetupSasAnalyticsRequest) *CustomersSetupSasAnalyticsCall {
  2695  	c := &CustomersSetupSasAnalyticsCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2696  	c.sasportalsetupsasanalyticsrequest = sasportalsetupsasanalyticsrequest
  2697  	return c
  2698  }
  2699  
  2700  // Fields allows partial responses to be retrieved. See
  2701  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2702  // details.
  2703  func (c *CustomersSetupSasAnalyticsCall) Fields(s ...googleapi.Field) *CustomersSetupSasAnalyticsCall {
  2704  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2705  	return c
  2706  }
  2707  
  2708  // Context sets the context to be used in this call's Do method.
  2709  func (c *CustomersSetupSasAnalyticsCall) Context(ctx context.Context) *CustomersSetupSasAnalyticsCall {
  2710  	c.ctx_ = ctx
  2711  	return c
  2712  }
  2713  
  2714  // Header returns a http.Header that can be modified by the caller to add
  2715  // headers to the request.
  2716  func (c *CustomersSetupSasAnalyticsCall) Header() http.Header {
  2717  	if c.header_ == nil {
  2718  		c.header_ = make(http.Header)
  2719  	}
  2720  	return c.header_
  2721  }
  2722  
  2723  func (c *CustomersSetupSasAnalyticsCall) doRequest(alt string) (*http.Response, error) {
  2724  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2725  	var body io.Reader = nil
  2726  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalsetupsasanalyticsrequest)
  2727  	if err != nil {
  2728  		return nil, err
  2729  	}
  2730  	c.urlParams_.Set("alt", alt)
  2731  	c.urlParams_.Set("prettyPrint", "false")
  2732  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/customers:setupSasAnalytics")
  2733  	urls += "?" + c.urlParams_.Encode()
  2734  	req, err := http.NewRequest("POST", urls, body)
  2735  	if err != nil {
  2736  		return nil, err
  2737  	}
  2738  	req.Header = reqHeaders
  2739  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2740  }
  2741  
  2742  // Do executes the "sasportal.customers.setupSasAnalytics" call.
  2743  // Any non-2xx status code is an error. Response headers are in either
  2744  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  2745  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2746  // check whether the returned error was because http.StatusNotModified was
  2747  // returned.
  2748  func (c *CustomersSetupSasAnalyticsCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  2749  	gensupport.SetOptions(c.urlParams_, opts...)
  2750  	res, err := c.doRequest("json")
  2751  	if res != nil && res.StatusCode == http.StatusNotModified {
  2752  		if res.Body != nil {
  2753  			res.Body.Close()
  2754  		}
  2755  		return nil, gensupport.WrapError(&googleapi.Error{
  2756  			Code:   res.StatusCode,
  2757  			Header: res.Header,
  2758  		})
  2759  	}
  2760  	if err != nil {
  2761  		return nil, err
  2762  	}
  2763  	defer googleapi.CloseBody(res)
  2764  	if err := googleapi.CheckResponse(res); err != nil {
  2765  		return nil, gensupport.WrapError(err)
  2766  	}
  2767  	ret := &SasPortalOperation{
  2768  		ServerResponse: googleapi.ServerResponse{
  2769  			Header:         res.Header,
  2770  			HTTPStatusCode: res.StatusCode,
  2771  		},
  2772  	}
  2773  	target := &ret
  2774  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2775  		return nil, err
  2776  	}
  2777  	return ret, nil
  2778  }
  2779  
  2780  type CustomersDeploymentsCreateCall struct {
  2781  	s                   *Service
  2782  	parent              string
  2783  	sasportaldeployment *SasPortalDeployment
  2784  	urlParams_          gensupport.URLParams
  2785  	ctx_                context.Context
  2786  	header_             http.Header
  2787  }
  2788  
  2789  // Create: Creates a new deployment.
  2790  //
  2791  // - parent: The parent resource name where the deployment is to be created.
  2792  func (r *CustomersDeploymentsService) Create(parent string, sasportaldeployment *SasPortalDeployment) *CustomersDeploymentsCreateCall {
  2793  	c := &CustomersDeploymentsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2794  	c.parent = parent
  2795  	c.sasportaldeployment = sasportaldeployment
  2796  	return c
  2797  }
  2798  
  2799  // Fields allows partial responses to be retrieved. See
  2800  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2801  // details.
  2802  func (c *CustomersDeploymentsCreateCall) Fields(s ...googleapi.Field) *CustomersDeploymentsCreateCall {
  2803  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2804  	return c
  2805  }
  2806  
  2807  // Context sets the context to be used in this call's Do method.
  2808  func (c *CustomersDeploymentsCreateCall) Context(ctx context.Context) *CustomersDeploymentsCreateCall {
  2809  	c.ctx_ = ctx
  2810  	return c
  2811  }
  2812  
  2813  // Header returns a http.Header that can be modified by the caller to add
  2814  // headers to the request.
  2815  func (c *CustomersDeploymentsCreateCall) Header() http.Header {
  2816  	if c.header_ == nil {
  2817  		c.header_ = make(http.Header)
  2818  	}
  2819  	return c.header_
  2820  }
  2821  
  2822  func (c *CustomersDeploymentsCreateCall) doRequest(alt string) (*http.Response, error) {
  2823  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  2824  	var body io.Reader = nil
  2825  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldeployment)
  2826  	if err != nil {
  2827  		return nil, err
  2828  	}
  2829  	c.urlParams_.Set("alt", alt)
  2830  	c.urlParams_.Set("prettyPrint", "false")
  2831  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  2832  	urls += "?" + c.urlParams_.Encode()
  2833  	req, err := http.NewRequest("POST", urls, body)
  2834  	if err != nil {
  2835  		return nil, err
  2836  	}
  2837  	req.Header = reqHeaders
  2838  	googleapi.Expand(req.URL, map[string]string{
  2839  		"parent": c.parent,
  2840  	})
  2841  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2842  }
  2843  
  2844  // Do executes the "sasportal.customers.deployments.create" call.
  2845  // Any non-2xx status code is an error. Response headers are in either
  2846  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  2847  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2848  // check whether the returned error was because http.StatusNotModified was
  2849  // returned.
  2850  func (c *CustomersDeploymentsCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  2851  	gensupport.SetOptions(c.urlParams_, opts...)
  2852  	res, err := c.doRequest("json")
  2853  	if res != nil && res.StatusCode == http.StatusNotModified {
  2854  		if res.Body != nil {
  2855  			res.Body.Close()
  2856  		}
  2857  		return nil, gensupport.WrapError(&googleapi.Error{
  2858  			Code:   res.StatusCode,
  2859  			Header: res.Header,
  2860  		})
  2861  	}
  2862  	if err != nil {
  2863  		return nil, err
  2864  	}
  2865  	defer googleapi.CloseBody(res)
  2866  	if err := googleapi.CheckResponse(res); err != nil {
  2867  		return nil, gensupport.WrapError(err)
  2868  	}
  2869  	ret := &SasPortalDeployment{
  2870  		ServerResponse: googleapi.ServerResponse{
  2871  			Header:         res.Header,
  2872  			HTTPStatusCode: res.StatusCode,
  2873  		},
  2874  	}
  2875  	target := &ret
  2876  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2877  		return nil, err
  2878  	}
  2879  	return ret, nil
  2880  }
  2881  
  2882  type CustomersDeploymentsDeleteCall struct {
  2883  	s          *Service
  2884  	name       string
  2885  	urlParams_ gensupport.URLParams
  2886  	ctx_       context.Context
  2887  	header_    http.Header
  2888  }
  2889  
  2890  // Delete: Deletes a deployment.
  2891  //
  2892  // - name: The name of the deployment.
  2893  func (r *CustomersDeploymentsService) Delete(name string) *CustomersDeploymentsDeleteCall {
  2894  	c := &CustomersDeploymentsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2895  	c.name = name
  2896  	return c
  2897  }
  2898  
  2899  // Fields allows partial responses to be retrieved. See
  2900  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2901  // details.
  2902  func (c *CustomersDeploymentsDeleteCall) Fields(s ...googleapi.Field) *CustomersDeploymentsDeleteCall {
  2903  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2904  	return c
  2905  }
  2906  
  2907  // Context sets the context to be used in this call's Do method.
  2908  func (c *CustomersDeploymentsDeleteCall) Context(ctx context.Context) *CustomersDeploymentsDeleteCall {
  2909  	c.ctx_ = ctx
  2910  	return c
  2911  }
  2912  
  2913  // Header returns a http.Header that can be modified by the caller to add
  2914  // headers to the request.
  2915  func (c *CustomersDeploymentsDeleteCall) Header() http.Header {
  2916  	if c.header_ == nil {
  2917  		c.header_ = make(http.Header)
  2918  	}
  2919  	return c.header_
  2920  }
  2921  
  2922  func (c *CustomersDeploymentsDeleteCall) doRequest(alt string) (*http.Response, error) {
  2923  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  2924  	var body io.Reader = nil
  2925  	c.urlParams_.Set("alt", alt)
  2926  	c.urlParams_.Set("prettyPrint", "false")
  2927  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  2928  	urls += "?" + c.urlParams_.Encode()
  2929  	req, err := http.NewRequest("DELETE", urls, body)
  2930  	if err != nil {
  2931  		return nil, err
  2932  	}
  2933  	req.Header = reqHeaders
  2934  	googleapi.Expand(req.URL, map[string]string{
  2935  		"name": c.name,
  2936  	})
  2937  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2938  }
  2939  
  2940  // Do executes the "sasportal.customers.deployments.delete" call.
  2941  // Any non-2xx status code is an error. Response headers are in either
  2942  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  2943  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  2944  // whether the returned error was because http.StatusNotModified was returned.
  2945  func (c *CustomersDeploymentsDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  2946  	gensupport.SetOptions(c.urlParams_, opts...)
  2947  	res, err := c.doRequest("json")
  2948  	if res != nil && res.StatusCode == http.StatusNotModified {
  2949  		if res.Body != nil {
  2950  			res.Body.Close()
  2951  		}
  2952  		return nil, gensupport.WrapError(&googleapi.Error{
  2953  			Code:   res.StatusCode,
  2954  			Header: res.Header,
  2955  		})
  2956  	}
  2957  	if err != nil {
  2958  		return nil, err
  2959  	}
  2960  	defer googleapi.CloseBody(res)
  2961  	if err := googleapi.CheckResponse(res); err != nil {
  2962  		return nil, gensupport.WrapError(err)
  2963  	}
  2964  	ret := &SasPortalEmpty{
  2965  		ServerResponse: googleapi.ServerResponse{
  2966  			Header:         res.Header,
  2967  			HTTPStatusCode: res.StatusCode,
  2968  		},
  2969  	}
  2970  	target := &ret
  2971  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2972  		return nil, err
  2973  	}
  2974  	return ret, nil
  2975  }
  2976  
  2977  type CustomersDeploymentsGetCall struct {
  2978  	s            *Service
  2979  	name         string
  2980  	urlParams_   gensupport.URLParams
  2981  	ifNoneMatch_ string
  2982  	ctx_         context.Context
  2983  	header_      http.Header
  2984  }
  2985  
  2986  // Get: Returns a requested deployment.
  2987  //
  2988  // - name: The name of the deployment.
  2989  func (r *CustomersDeploymentsService) Get(name string) *CustomersDeploymentsGetCall {
  2990  	c := &CustomersDeploymentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2991  	c.name = name
  2992  	return c
  2993  }
  2994  
  2995  // Fields allows partial responses to be retrieved. See
  2996  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  2997  // details.
  2998  func (c *CustomersDeploymentsGetCall) Fields(s ...googleapi.Field) *CustomersDeploymentsGetCall {
  2999  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3000  	return c
  3001  }
  3002  
  3003  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  3004  // object's ETag matches the given value. This is useful for getting updates
  3005  // only after the object has changed since the last request.
  3006  func (c *CustomersDeploymentsGetCall) IfNoneMatch(entityTag string) *CustomersDeploymentsGetCall {
  3007  	c.ifNoneMatch_ = entityTag
  3008  	return c
  3009  }
  3010  
  3011  // Context sets the context to be used in this call's Do method.
  3012  func (c *CustomersDeploymentsGetCall) Context(ctx context.Context) *CustomersDeploymentsGetCall {
  3013  	c.ctx_ = ctx
  3014  	return c
  3015  }
  3016  
  3017  // Header returns a http.Header that can be modified by the caller to add
  3018  // headers to the request.
  3019  func (c *CustomersDeploymentsGetCall) Header() http.Header {
  3020  	if c.header_ == nil {
  3021  		c.header_ = make(http.Header)
  3022  	}
  3023  	return c.header_
  3024  }
  3025  
  3026  func (c *CustomersDeploymentsGetCall) doRequest(alt string) (*http.Response, error) {
  3027  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3028  	if c.ifNoneMatch_ != "" {
  3029  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  3030  	}
  3031  	var body io.Reader = nil
  3032  	c.urlParams_.Set("alt", alt)
  3033  	c.urlParams_.Set("prettyPrint", "false")
  3034  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  3035  	urls += "?" + c.urlParams_.Encode()
  3036  	req, err := http.NewRequest("GET", urls, body)
  3037  	if err != nil {
  3038  		return nil, err
  3039  	}
  3040  	req.Header = reqHeaders
  3041  	googleapi.Expand(req.URL, map[string]string{
  3042  		"name": c.name,
  3043  	})
  3044  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3045  }
  3046  
  3047  // Do executes the "sasportal.customers.deployments.get" call.
  3048  // Any non-2xx status code is an error. Response headers are in either
  3049  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  3050  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3051  // check whether the returned error was because http.StatusNotModified was
  3052  // returned.
  3053  func (c *CustomersDeploymentsGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  3054  	gensupport.SetOptions(c.urlParams_, opts...)
  3055  	res, err := c.doRequest("json")
  3056  	if res != nil && res.StatusCode == http.StatusNotModified {
  3057  		if res.Body != nil {
  3058  			res.Body.Close()
  3059  		}
  3060  		return nil, gensupport.WrapError(&googleapi.Error{
  3061  			Code:   res.StatusCode,
  3062  			Header: res.Header,
  3063  		})
  3064  	}
  3065  	if err != nil {
  3066  		return nil, err
  3067  	}
  3068  	defer googleapi.CloseBody(res)
  3069  	if err := googleapi.CheckResponse(res); err != nil {
  3070  		return nil, gensupport.WrapError(err)
  3071  	}
  3072  	ret := &SasPortalDeployment{
  3073  		ServerResponse: googleapi.ServerResponse{
  3074  			Header:         res.Header,
  3075  			HTTPStatusCode: res.StatusCode,
  3076  		},
  3077  	}
  3078  	target := &ret
  3079  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3080  		return nil, err
  3081  	}
  3082  	return ret, nil
  3083  }
  3084  
  3085  type CustomersDeploymentsListCall struct {
  3086  	s            *Service
  3087  	parent       string
  3088  	urlParams_   gensupport.URLParams
  3089  	ifNoneMatch_ string
  3090  	ctx_         context.Context
  3091  	header_      http.Header
  3092  }
  3093  
  3094  // List: Lists deployments.
  3095  //
  3096  //   - parent: The parent resource name, for example, "nodes/1",
  3097  //     customer/1/nodes/2.
  3098  func (r *CustomersDeploymentsService) List(parent string) *CustomersDeploymentsListCall {
  3099  	c := &CustomersDeploymentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3100  	c.parent = parent
  3101  	return c
  3102  }
  3103  
  3104  // Filter sets the optional parameter "filter": The filter expression. The
  3105  // filter should have the following format: "DIRECT_CHILDREN" or format:
  3106  // "direct_children". The filter is case insensitive. If empty, then no
  3107  // deployments are filtered.
  3108  func (c *CustomersDeploymentsListCall) Filter(filter string) *CustomersDeploymentsListCall {
  3109  	c.urlParams_.Set("filter", filter)
  3110  	return c
  3111  }
  3112  
  3113  // PageSize sets the optional parameter "pageSize": The maximum number of
  3114  // deployments to return in the response.
  3115  func (c *CustomersDeploymentsListCall) PageSize(pageSize int64) *CustomersDeploymentsListCall {
  3116  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  3117  	return c
  3118  }
  3119  
  3120  // PageToken sets the optional parameter "pageToken": A pagination token
  3121  // returned from a previous call to ListDeployments that indicates where this
  3122  // listing should continue from.
  3123  func (c *CustomersDeploymentsListCall) PageToken(pageToken string) *CustomersDeploymentsListCall {
  3124  	c.urlParams_.Set("pageToken", pageToken)
  3125  	return c
  3126  }
  3127  
  3128  // Fields allows partial responses to be retrieved. See
  3129  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3130  // details.
  3131  func (c *CustomersDeploymentsListCall) Fields(s ...googleapi.Field) *CustomersDeploymentsListCall {
  3132  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3133  	return c
  3134  }
  3135  
  3136  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  3137  // object's ETag matches the given value. This is useful for getting updates
  3138  // only after the object has changed since the last request.
  3139  func (c *CustomersDeploymentsListCall) IfNoneMatch(entityTag string) *CustomersDeploymentsListCall {
  3140  	c.ifNoneMatch_ = entityTag
  3141  	return c
  3142  }
  3143  
  3144  // Context sets the context to be used in this call's Do method.
  3145  func (c *CustomersDeploymentsListCall) Context(ctx context.Context) *CustomersDeploymentsListCall {
  3146  	c.ctx_ = ctx
  3147  	return c
  3148  }
  3149  
  3150  // Header returns a http.Header that can be modified by the caller to add
  3151  // headers to the request.
  3152  func (c *CustomersDeploymentsListCall) Header() http.Header {
  3153  	if c.header_ == nil {
  3154  		c.header_ = make(http.Header)
  3155  	}
  3156  	return c.header_
  3157  }
  3158  
  3159  func (c *CustomersDeploymentsListCall) doRequest(alt string) (*http.Response, error) {
  3160  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3161  	if c.ifNoneMatch_ != "" {
  3162  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  3163  	}
  3164  	var body io.Reader = nil
  3165  	c.urlParams_.Set("alt", alt)
  3166  	c.urlParams_.Set("prettyPrint", "false")
  3167  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  3168  	urls += "?" + c.urlParams_.Encode()
  3169  	req, err := http.NewRequest("GET", urls, body)
  3170  	if err != nil {
  3171  		return nil, err
  3172  	}
  3173  	req.Header = reqHeaders
  3174  	googleapi.Expand(req.URL, map[string]string{
  3175  		"parent": c.parent,
  3176  	})
  3177  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3178  }
  3179  
  3180  // Do executes the "sasportal.customers.deployments.list" call.
  3181  // Any non-2xx status code is an error. Response headers are in either
  3182  // *SasPortalListDeploymentsResponse.ServerResponse.Header or (if a response
  3183  // was returned at all) in error.(*googleapi.Error).Header. Use
  3184  // googleapi.IsNotModified to check whether the returned error was because
  3185  // http.StatusNotModified was returned.
  3186  func (c *CustomersDeploymentsListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDeploymentsResponse, error) {
  3187  	gensupport.SetOptions(c.urlParams_, opts...)
  3188  	res, err := c.doRequest("json")
  3189  	if res != nil && res.StatusCode == http.StatusNotModified {
  3190  		if res.Body != nil {
  3191  			res.Body.Close()
  3192  		}
  3193  		return nil, gensupport.WrapError(&googleapi.Error{
  3194  			Code:   res.StatusCode,
  3195  			Header: res.Header,
  3196  		})
  3197  	}
  3198  	if err != nil {
  3199  		return nil, err
  3200  	}
  3201  	defer googleapi.CloseBody(res)
  3202  	if err := googleapi.CheckResponse(res); err != nil {
  3203  		return nil, gensupport.WrapError(err)
  3204  	}
  3205  	ret := &SasPortalListDeploymentsResponse{
  3206  		ServerResponse: googleapi.ServerResponse{
  3207  			Header:         res.Header,
  3208  			HTTPStatusCode: res.StatusCode,
  3209  		},
  3210  	}
  3211  	target := &ret
  3212  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3213  		return nil, err
  3214  	}
  3215  	return ret, nil
  3216  }
  3217  
  3218  // Pages invokes f for each page of results.
  3219  // A non-nil error returned from f will halt the iteration.
  3220  // The provided context supersedes any context provided to the Context method.
  3221  func (c *CustomersDeploymentsListCall) Pages(ctx context.Context, f func(*SasPortalListDeploymentsResponse) error) error {
  3222  	c.ctx_ = ctx
  3223  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  3224  	for {
  3225  		x, err := c.Do()
  3226  		if err != nil {
  3227  			return err
  3228  		}
  3229  		if err := f(x); err != nil {
  3230  			return err
  3231  		}
  3232  		if x.NextPageToken == "" {
  3233  			return nil
  3234  		}
  3235  		c.PageToken(x.NextPageToken)
  3236  	}
  3237  }
  3238  
  3239  type CustomersDeploymentsMoveCall struct {
  3240  	s                              *Service
  3241  	name                           string
  3242  	sasportalmovedeploymentrequest *SasPortalMoveDeploymentRequest
  3243  	urlParams_                     gensupport.URLParams
  3244  	ctx_                           context.Context
  3245  	header_                        http.Header
  3246  }
  3247  
  3248  // Move: Moves a deployment under another node or customer.
  3249  //
  3250  // - name: The name of the deployment to move.
  3251  func (r *CustomersDeploymentsService) Move(name string, sasportalmovedeploymentrequest *SasPortalMoveDeploymentRequest) *CustomersDeploymentsMoveCall {
  3252  	c := &CustomersDeploymentsMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3253  	c.name = name
  3254  	c.sasportalmovedeploymentrequest = sasportalmovedeploymentrequest
  3255  	return c
  3256  }
  3257  
  3258  // Fields allows partial responses to be retrieved. See
  3259  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3260  // details.
  3261  func (c *CustomersDeploymentsMoveCall) Fields(s ...googleapi.Field) *CustomersDeploymentsMoveCall {
  3262  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3263  	return c
  3264  }
  3265  
  3266  // Context sets the context to be used in this call's Do method.
  3267  func (c *CustomersDeploymentsMoveCall) Context(ctx context.Context) *CustomersDeploymentsMoveCall {
  3268  	c.ctx_ = ctx
  3269  	return c
  3270  }
  3271  
  3272  // Header returns a http.Header that can be modified by the caller to add
  3273  // headers to the request.
  3274  func (c *CustomersDeploymentsMoveCall) Header() http.Header {
  3275  	if c.header_ == nil {
  3276  		c.header_ = make(http.Header)
  3277  	}
  3278  	return c.header_
  3279  }
  3280  
  3281  func (c *CustomersDeploymentsMoveCall) doRequest(alt string) (*http.Response, error) {
  3282  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3283  	var body io.Reader = nil
  3284  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovedeploymentrequest)
  3285  	if err != nil {
  3286  		return nil, err
  3287  	}
  3288  	c.urlParams_.Set("alt", alt)
  3289  	c.urlParams_.Set("prettyPrint", "false")
  3290  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  3291  	urls += "?" + c.urlParams_.Encode()
  3292  	req, err := http.NewRequest("POST", urls, body)
  3293  	if err != nil {
  3294  		return nil, err
  3295  	}
  3296  	req.Header = reqHeaders
  3297  	googleapi.Expand(req.URL, map[string]string{
  3298  		"name": c.name,
  3299  	})
  3300  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3301  }
  3302  
  3303  // Do executes the "sasportal.customers.deployments.move" call.
  3304  // Any non-2xx status code is an error. Response headers are in either
  3305  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  3306  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3307  // check whether the returned error was because http.StatusNotModified was
  3308  // returned.
  3309  func (c *CustomersDeploymentsMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  3310  	gensupport.SetOptions(c.urlParams_, opts...)
  3311  	res, err := c.doRequest("json")
  3312  	if res != nil && res.StatusCode == http.StatusNotModified {
  3313  		if res.Body != nil {
  3314  			res.Body.Close()
  3315  		}
  3316  		return nil, gensupport.WrapError(&googleapi.Error{
  3317  			Code:   res.StatusCode,
  3318  			Header: res.Header,
  3319  		})
  3320  	}
  3321  	if err != nil {
  3322  		return nil, err
  3323  	}
  3324  	defer googleapi.CloseBody(res)
  3325  	if err := googleapi.CheckResponse(res); err != nil {
  3326  		return nil, gensupport.WrapError(err)
  3327  	}
  3328  	ret := &SasPortalOperation{
  3329  		ServerResponse: googleapi.ServerResponse{
  3330  			Header:         res.Header,
  3331  			HTTPStatusCode: res.StatusCode,
  3332  		},
  3333  	}
  3334  	target := &ret
  3335  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3336  		return nil, err
  3337  	}
  3338  	return ret, nil
  3339  }
  3340  
  3341  type CustomersDeploymentsPatchCall struct {
  3342  	s                   *Service
  3343  	name                string
  3344  	sasportaldeployment *SasPortalDeployment
  3345  	urlParams_          gensupport.URLParams
  3346  	ctx_                context.Context
  3347  	header_             http.Header
  3348  }
  3349  
  3350  // Patch: Updates an existing deployment.
  3351  //
  3352  // - name: Output only. Resource name.
  3353  func (r *CustomersDeploymentsService) Patch(name string, sasportaldeployment *SasPortalDeployment) *CustomersDeploymentsPatchCall {
  3354  	c := &CustomersDeploymentsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3355  	c.name = name
  3356  	c.sasportaldeployment = sasportaldeployment
  3357  	return c
  3358  }
  3359  
  3360  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  3361  func (c *CustomersDeploymentsPatchCall) UpdateMask(updateMask string) *CustomersDeploymentsPatchCall {
  3362  	c.urlParams_.Set("updateMask", updateMask)
  3363  	return c
  3364  }
  3365  
  3366  // Fields allows partial responses to be retrieved. See
  3367  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3368  // details.
  3369  func (c *CustomersDeploymentsPatchCall) Fields(s ...googleapi.Field) *CustomersDeploymentsPatchCall {
  3370  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3371  	return c
  3372  }
  3373  
  3374  // Context sets the context to be used in this call's Do method.
  3375  func (c *CustomersDeploymentsPatchCall) Context(ctx context.Context) *CustomersDeploymentsPatchCall {
  3376  	c.ctx_ = ctx
  3377  	return c
  3378  }
  3379  
  3380  // Header returns a http.Header that can be modified by the caller to add
  3381  // headers to the request.
  3382  func (c *CustomersDeploymentsPatchCall) Header() http.Header {
  3383  	if c.header_ == nil {
  3384  		c.header_ = make(http.Header)
  3385  	}
  3386  	return c.header_
  3387  }
  3388  
  3389  func (c *CustomersDeploymentsPatchCall) doRequest(alt string) (*http.Response, error) {
  3390  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3391  	var body io.Reader = nil
  3392  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldeployment)
  3393  	if err != nil {
  3394  		return nil, err
  3395  	}
  3396  	c.urlParams_.Set("alt", alt)
  3397  	c.urlParams_.Set("prettyPrint", "false")
  3398  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  3399  	urls += "?" + c.urlParams_.Encode()
  3400  	req, err := http.NewRequest("PATCH", urls, body)
  3401  	if err != nil {
  3402  		return nil, err
  3403  	}
  3404  	req.Header = reqHeaders
  3405  	googleapi.Expand(req.URL, map[string]string{
  3406  		"name": c.name,
  3407  	})
  3408  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3409  }
  3410  
  3411  // Do executes the "sasportal.customers.deployments.patch" call.
  3412  // Any non-2xx status code is an error. Response headers are in either
  3413  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  3414  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3415  // check whether the returned error was because http.StatusNotModified was
  3416  // returned.
  3417  func (c *CustomersDeploymentsPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  3418  	gensupport.SetOptions(c.urlParams_, opts...)
  3419  	res, err := c.doRequest("json")
  3420  	if res != nil && res.StatusCode == http.StatusNotModified {
  3421  		if res.Body != nil {
  3422  			res.Body.Close()
  3423  		}
  3424  		return nil, gensupport.WrapError(&googleapi.Error{
  3425  			Code:   res.StatusCode,
  3426  			Header: res.Header,
  3427  		})
  3428  	}
  3429  	if err != nil {
  3430  		return nil, err
  3431  	}
  3432  	defer googleapi.CloseBody(res)
  3433  	if err := googleapi.CheckResponse(res); err != nil {
  3434  		return nil, gensupport.WrapError(err)
  3435  	}
  3436  	ret := &SasPortalDeployment{
  3437  		ServerResponse: googleapi.ServerResponse{
  3438  			Header:         res.Header,
  3439  			HTTPStatusCode: res.StatusCode,
  3440  		},
  3441  	}
  3442  	target := &ret
  3443  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3444  		return nil, err
  3445  	}
  3446  	return ret, nil
  3447  }
  3448  
  3449  type CustomersDeploymentsDevicesCreateCall struct {
  3450  	s               *Service
  3451  	parent          string
  3452  	sasportaldevice *SasPortalDevice
  3453  	urlParams_      gensupport.URLParams
  3454  	ctx_            context.Context
  3455  	header_         http.Header
  3456  }
  3457  
  3458  // Create: Creates a device under a node or customer.
  3459  //
  3460  // - parent: The name of the parent resource.
  3461  func (r *CustomersDeploymentsDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *CustomersDeploymentsDevicesCreateCall {
  3462  	c := &CustomersDeploymentsDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3463  	c.parent = parent
  3464  	c.sasportaldevice = sasportaldevice
  3465  	return c
  3466  }
  3467  
  3468  // Fields allows partial responses to be retrieved. See
  3469  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3470  // details.
  3471  func (c *CustomersDeploymentsDevicesCreateCall) Fields(s ...googleapi.Field) *CustomersDeploymentsDevicesCreateCall {
  3472  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3473  	return c
  3474  }
  3475  
  3476  // Context sets the context to be used in this call's Do method.
  3477  func (c *CustomersDeploymentsDevicesCreateCall) Context(ctx context.Context) *CustomersDeploymentsDevicesCreateCall {
  3478  	c.ctx_ = ctx
  3479  	return c
  3480  }
  3481  
  3482  // Header returns a http.Header that can be modified by the caller to add
  3483  // headers to the request.
  3484  func (c *CustomersDeploymentsDevicesCreateCall) Header() http.Header {
  3485  	if c.header_ == nil {
  3486  		c.header_ = make(http.Header)
  3487  	}
  3488  	return c.header_
  3489  }
  3490  
  3491  func (c *CustomersDeploymentsDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
  3492  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3493  	var body io.Reader = nil
  3494  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  3495  	if err != nil {
  3496  		return nil, err
  3497  	}
  3498  	c.urlParams_.Set("alt", alt)
  3499  	c.urlParams_.Set("prettyPrint", "false")
  3500  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  3501  	urls += "?" + c.urlParams_.Encode()
  3502  	req, err := http.NewRequest("POST", urls, body)
  3503  	if err != nil {
  3504  		return nil, err
  3505  	}
  3506  	req.Header = reqHeaders
  3507  	googleapi.Expand(req.URL, map[string]string{
  3508  		"parent": c.parent,
  3509  	})
  3510  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3511  }
  3512  
  3513  // Do executes the "sasportal.customers.deployments.devices.create" call.
  3514  // Any non-2xx status code is an error. Response headers are in either
  3515  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  3516  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3517  // check whether the returned error was because http.StatusNotModified was
  3518  // returned.
  3519  func (c *CustomersDeploymentsDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  3520  	gensupport.SetOptions(c.urlParams_, opts...)
  3521  	res, err := c.doRequest("json")
  3522  	if res != nil && res.StatusCode == http.StatusNotModified {
  3523  		if res.Body != nil {
  3524  			res.Body.Close()
  3525  		}
  3526  		return nil, gensupport.WrapError(&googleapi.Error{
  3527  			Code:   res.StatusCode,
  3528  			Header: res.Header,
  3529  		})
  3530  	}
  3531  	if err != nil {
  3532  		return nil, err
  3533  	}
  3534  	defer googleapi.CloseBody(res)
  3535  	if err := googleapi.CheckResponse(res); err != nil {
  3536  		return nil, gensupport.WrapError(err)
  3537  	}
  3538  	ret := &SasPortalDevice{
  3539  		ServerResponse: googleapi.ServerResponse{
  3540  			Header:         res.Header,
  3541  			HTTPStatusCode: res.StatusCode,
  3542  		},
  3543  	}
  3544  	target := &ret
  3545  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3546  		return nil, err
  3547  	}
  3548  	return ret, nil
  3549  }
  3550  
  3551  type CustomersDeploymentsDevicesCreateSignedCall struct {
  3552  	s                                  *Service
  3553  	parent                             string
  3554  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
  3555  	urlParams_                         gensupport.URLParams
  3556  	ctx_                               context.Context
  3557  	header_                            http.Header
  3558  }
  3559  
  3560  // CreateSigned: Creates a signed device under a node or customer.
  3561  //
  3562  // - parent: The name of the parent resource.
  3563  func (r *CustomersDeploymentsDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *CustomersDeploymentsDevicesCreateSignedCall {
  3564  	c := &CustomersDeploymentsDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3565  	c.parent = parent
  3566  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
  3567  	return c
  3568  }
  3569  
  3570  // Fields allows partial responses to be retrieved. See
  3571  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3572  // details.
  3573  func (c *CustomersDeploymentsDevicesCreateSignedCall) Fields(s ...googleapi.Field) *CustomersDeploymentsDevicesCreateSignedCall {
  3574  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3575  	return c
  3576  }
  3577  
  3578  // Context sets the context to be used in this call's Do method.
  3579  func (c *CustomersDeploymentsDevicesCreateSignedCall) Context(ctx context.Context) *CustomersDeploymentsDevicesCreateSignedCall {
  3580  	c.ctx_ = ctx
  3581  	return c
  3582  }
  3583  
  3584  // Header returns a http.Header that can be modified by the caller to add
  3585  // headers to the request.
  3586  func (c *CustomersDeploymentsDevicesCreateSignedCall) Header() http.Header {
  3587  	if c.header_ == nil {
  3588  		c.header_ = make(http.Header)
  3589  	}
  3590  	return c.header_
  3591  }
  3592  
  3593  func (c *CustomersDeploymentsDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
  3594  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3595  	var body io.Reader = nil
  3596  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
  3597  	if err != nil {
  3598  		return nil, err
  3599  	}
  3600  	c.urlParams_.Set("alt", alt)
  3601  	c.urlParams_.Set("prettyPrint", "false")
  3602  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
  3603  	urls += "?" + c.urlParams_.Encode()
  3604  	req, err := http.NewRequest("POST", urls, body)
  3605  	if err != nil {
  3606  		return nil, err
  3607  	}
  3608  	req.Header = reqHeaders
  3609  	googleapi.Expand(req.URL, map[string]string{
  3610  		"parent": c.parent,
  3611  	})
  3612  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3613  }
  3614  
  3615  // Do executes the "sasportal.customers.deployments.devices.createSigned" call.
  3616  // Any non-2xx status code is an error. Response headers are in either
  3617  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  3618  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3619  // check whether the returned error was because http.StatusNotModified was
  3620  // returned.
  3621  func (c *CustomersDeploymentsDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  3622  	gensupport.SetOptions(c.urlParams_, opts...)
  3623  	res, err := c.doRequest("json")
  3624  	if res != nil && res.StatusCode == http.StatusNotModified {
  3625  		if res.Body != nil {
  3626  			res.Body.Close()
  3627  		}
  3628  		return nil, gensupport.WrapError(&googleapi.Error{
  3629  			Code:   res.StatusCode,
  3630  			Header: res.Header,
  3631  		})
  3632  	}
  3633  	if err != nil {
  3634  		return nil, err
  3635  	}
  3636  	defer googleapi.CloseBody(res)
  3637  	if err := googleapi.CheckResponse(res); err != nil {
  3638  		return nil, gensupport.WrapError(err)
  3639  	}
  3640  	ret := &SasPortalDevice{
  3641  		ServerResponse: googleapi.ServerResponse{
  3642  			Header:         res.Header,
  3643  			HTTPStatusCode: res.StatusCode,
  3644  		},
  3645  	}
  3646  	target := &ret
  3647  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3648  		return nil, err
  3649  	}
  3650  	return ret, nil
  3651  }
  3652  
  3653  type CustomersDeploymentsDevicesListCall struct {
  3654  	s            *Service
  3655  	parent       string
  3656  	urlParams_   gensupport.URLParams
  3657  	ifNoneMatch_ string
  3658  	ctx_         context.Context
  3659  	header_      http.Header
  3660  }
  3661  
  3662  // List: Lists devices under a node or customer.
  3663  //
  3664  // - parent: The name of the parent resource.
  3665  func (r *CustomersDeploymentsDevicesService) List(parent string) *CustomersDeploymentsDevicesListCall {
  3666  	c := &CustomersDeploymentsDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3667  	c.parent = parent
  3668  	return c
  3669  }
  3670  
  3671  // Filter sets the optional parameter "filter": The filter expression. The
  3672  // filter should have one of the following formats: "sn=123454" or
  3673  // "display_name=MyDevice". sn corresponds to serial number of the device. The
  3674  // filter is case insensitive.
  3675  func (c *CustomersDeploymentsDevicesListCall) Filter(filter string) *CustomersDeploymentsDevicesListCall {
  3676  	c.urlParams_.Set("filter", filter)
  3677  	return c
  3678  }
  3679  
  3680  // PageSize sets the optional parameter "pageSize": The maximum number of
  3681  // devices to return in the response. If empty or zero, all devices will be
  3682  // listed. Must be in the range [0, 1000].
  3683  func (c *CustomersDeploymentsDevicesListCall) PageSize(pageSize int64) *CustomersDeploymentsDevicesListCall {
  3684  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  3685  	return c
  3686  }
  3687  
  3688  // PageToken sets the optional parameter "pageToken": A pagination token
  3689  // returned from a previous call to ListDevices that indicates where this
  3690  // listing should continue from.
  3691  func (c *CustomersDeploymentsDevicesListCall) PageToken(pageToken string) *CustomersDeploymentsDevicesListCall {
  3692  	c.urlParams_.Set("pageToken", pageToken)
  3693  	return c
  3694  }
  3695  
  3696  // Fields allows partial responses to be retrieved. See
  3697  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3698  // details.
  3699  func (c *CustomersDeploymentsDevicesListCall) Fields(s ...googleapi.Field) *CustomersDeploymentsDevicesListCall {
  3700  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3701  	return c
  3702  }
  3703  
  3704  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  3705  // object's ETag matches the given value. This is useful for getting updates
  3706  // only after the object has changed since the last request.
  3707  func (c *CustomersDeploymentsDevicesListCall) IfNoneMatch(entityTag string) *CustomersDeploymentsDevicesListCall {
  3708  	c.ifNoneMatch_ = entityTag
  3709  	return c
  3710  }
  3711  
  3712  // Context sets the context to be used in this call's Do method.
  3713  func (c *CustomersDeploymentsDevicesListCall) Context(ctx context.Context) *CustomersDeploymentsDevicesListCall {
  3714  	c.ctx_ = ctx
  3715  	return c
  3716  }
  3717  
  3718  // Header returns a http.Header that can be modified by the caller to add
  3719  // headers to the request.
  3720  func (c *CustomersDeploymentsDevicesListCall) Header() http.Header {
  3721  	if c.header_ == nil {
  3722  		c.header_ = make(http.Header)
  3723  	}
  3724  	return c.header_
  3725  }
  3726  
  3727  func (c *CustomersDeploymentsDevicesListCall) doRequest(alt string) (*http.Response, error) {
  3728  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  3729  	if c.ifNoneMatch_ != "" {
  3730  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  3731  	}
  3732  	var body io.Reader = nil
  3733  	c.urlParams_.Set("alt", alt)
  3734  	c.urlParams_.Set("prettyPrint", "false")
  3735  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  3736  	urls += "?" + c.urlParams_.Encode()
  3737  	req, err := http.NewRequest("GET", urls, body)
  3738  	if err != nil {
  3739  		return nil, err
  3740  	}
  3741  	req.Header = reqHeaders
  3742  	googleapi.Expand(req.URL, map[string]string{
  3743  		"parent": c.parent,
  3744  	})
  3745  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3746  }
  3747  
  3748  // Do executes the "sasportal.customers.deployments.devices.list" call.
  3749  // Any non-2xx status code is an error. Response headers are in either
  3750  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
  3751  // returned at all) in error.(*googleapi.Error).Header. Use
  3752  // googleapi.IsNotModified to check whether the returned error was because
  3753  // http.StatusNotModified was returned.
  3754  func (c *CustomersDeploymentsDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
  3755  	gensupport.SetOptions(c.urlParams_, opts...)
  3756  	res, err := c.doRequest("json")
  3757  	if res != nil && res.StatusCode == http.StatusNotModified {
  3758  		if res.Body != nil {
  3759  			res.Body.Close()
  3760  		}
  3761  		return nil, gensupport.WrapError(&googleapi.Error{
  3762  			Code:   res.StatusCode,
  3763  			Header: res.Header,
  3764  		})
  3765  	}
  3766  	if err != nil {
  3767  		return nil, err
  3768  	}
  3769  	defer googleapi.CloseBody(res)
  3770  	if err := googleapi.CheckResponse(res); err != nil {
  3771  		return nil, gensupport.WrapError(err)
  3772  	}
  3773  	ret := &SasPortalListDevicesResponse{
  3774  		ServerResponse: googleapi.ServerResponse{
  3775  			Header:         res.Header,
  3776  			HTTPStatusCode: res.StatusCode,
  3777  		},
  3778  	}
  3779  	target := &ret
  3780  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3781  		return nil, err
  3782  	}
  3783  	return ret, nil
  3784  }
  3785  
  3786  // Pages invokes f for each page of results.
  3787  // A non-nil error returned from f will halt the iteration.
  3788  // The provided context supersedes any context provided to the Context method.
  3789  func (c *CustomersDeploymentsDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
  3790  	c.ctx_ = ctx
  3791  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  3792  	for {
  3793  		x, err := c.Do()
  3794  		if err != nil {
  3795  			return err
  3796  		}
  3797  		if err := f(x); err != nil {
  3798  			return err
  3799  		}
  3800  		if x.NextPageToken == "" {
  3801  			return nil
  3802  		}
  3803  		c.PageToken(x.NextPageToken)
  3804  	}
  3805  }
  3806  
  3807  type CustomersDevicesCreateCall struct {
  3808  	s               *Service
  3809  	parent          string
  3810  	sasportaldevice *SasPortalDevice
  3811  	urlParams_      gensupport.URLParams
  3812  	ctx_            context.Context
  3813  	header_         http.Header
  3814  }
  3815  
  3816  // Create: Creates a device under a node or customer.
  3817  //
  3818  // - parent: The name of the parent resource.
  3819  func (r *CustomersDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *CustomersDevicesCreateCall {
  3820  	c := &CustomersDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3821  	c.parent = parent
  3822  	c.sasportaldevice = sasportaldevice
  3823  	return c
  3824  }
  3825  
  3826  // Fields allows partial responses to be retrieved. See
  3827  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3828  // details.
  3829  func (c *CustomersDevicesCreateCall) Fields(s ...googleapi.Field) *CustomersDevicesCreateCall {
  3830  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3831  	return c
  3832  }
  3833  
  3834  // Context sets the context to be used in this call's Do method.
  3835  func (c *CustomersDevicesCreateCall) Context(ctx context.Context) *CustomersDevicesCreateCall {
  3836  	c.ctx_ = ctx
  3837  	return c
  3838  }
  3839  
  3840  // Header returns a http.Header that can be modified by the caller to add
  3841  // headers to the request.
  3842  func (c *CustomersDevicesCreateCall) Header() http.Header {
  3843  	if c.header_ == nil {
  3844  		c.header_ = make(http.Header)
  3845  	}
  3846  	return c.header_
  3847  }
  3848  
  3849  func (c *CustomersDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
  3850  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3851  	var body io.Reader = nil
  3852  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  3853  	if err != nil {
  3854  		return nil, err
  3855  	}
  3856  	c.urlParams_.Set("alt", alt)
  3857  	c.urlParams_.Set("prettyPrint", "false")
  3858  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  3859  	urls += "?" + c.urlParams_.Encode()
  3860  	req, err := http.NewRequest("POST", urls, body)
  3861  	if err != nil {
  3862  		return nil, err
  3863  	}
  3864  	req.Header = reqHeaders
  3865  	googleapi.Expand(req.URL, map[string]string{
  3866  		"parent": c.parent,
  3867  	})
  3868  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3869  }
  3870  
  3871  // Do executes the "sasportal.customers.devices.create" call.
  3872  // Any non-2xx status code is an error. Response headers are in either
  3873  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  3874  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3875  // check whether the returned error was because http.StatusNotModified was
  3876  // returned.
  3877  func (c *CustomersDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  3878  	gensupport.SetOptions(c.urlParams_, opts...)
  3879  	res, err := c.doRequest("json")
  3880  	if res != nil && res.StatusCode == http.StatusNotModified {
  3881  		if res.Body != nil {
  3882  			res.Body.Close()
  3883  		}
  3884  		return nil, gensupport.WrapError(&googleapi.Error{
  3885  			Code:   res.StatusCode,
  3886  			Header: res.Header,
  3887  		})
  3888  	}
  3889  	if err != nil {
  3890  		return nil, err
  3891  	}
  3892  	defer googleapi.CloseBody(res)
  3893  	if err := googleapi.CheckResponse(res); err != nil {
  3894  		return nil, gensupport.WrapError(err)
  3895  	}
  3896  	ret := &SasPortalDevice{
  3897  		ServerResponse: googleapi.ServerResponse{
  3898  			Header:         res.Header,
  3899  			HTTPStatusCode: res.StatusCode,
  3900  		},
  3901  	}
  3902  	target := &ret
  3903  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3904  		return nil, err
  3905  	}
  3906  	return ret, nil
  3907  }
  3908  
  3909  type CustomersDevicesCreateSignedCall struct {
  3910  	s                                  *Service
  3911  	parent                             string
  3912  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
  3913  	urlParams_                         gensupport.URLParams
  3914  	ctx_                               context.Context
  3915  	header_                            http.Header
  3916  }
  3917  
  3918  // CreateSigned: Creates a signed device under a node or customer.
  3919  //
  3920  // - parent: The name of the parent resource.
  3921  func (r *CustomersDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *CustomersDevicesCreateSignedCall {
  3922  	c := &CustomersDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3923  	c.parent = parent
  3924  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
  3925  	return c
  3926  }
  3927  
  3928  // Fields allows partial responses to be retrieved. See
  3929  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  3930  // details.
  3931  func (c *CustomersDevicesCreateSignedCall) Fields(s ...googleapi.Field) *CustomersDevicesCreateSignedCall {
  3932  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3933  	return c
  3934  }
  3935  
  3936  // Context sets the context to be used in this call's Do method.
  3937  func (c *CustomersDevicesCreateSignedCall) Context(ctx context.Context) *CustomersDevicesCreateSignedCall {
  3938  	c.ctx_ = ctx
  3939  	return c
  3940  }
  3941  
  3942  // Header returns a http.Header that can be modified by the caller to add
  3943  // headers to the request.
  3944  func (c *CustomersDevicesCreateSignedCall) Header() http.Header {
  3945  	if c.header_ == nil {
  3946  		c.header_ = make(http.Header)
  3947  	}
  3948  	return c.header_
  3949  }
  3950  
  3951  func (c *CustomersDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
  3952  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  3953  	var body io.Reader = nil
  3954  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
  3955  	if err != nil {
  3956  		return nil, err
  3957  	}
  3958  	c.urlParams_.Set("alt", alt)
  3959  	c.urlParams_.Set("prettyPrint", "false")
  3960  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
  3961  	urls += "?" + c.urlParams_.Encode()
  3962  	req, err := http.NewRequest("POST", urls, body)
  3963  	if err != nil {
  3964  		return nil, err
  3965  	}
  3966  	req.Header = reqHeaders
  3967  	googleapi.Expand(req.URL, map[string]string{
  3968  		"parent": c.parent,
  3969  	})
  3970  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3971  }
  3972  
  3973  // Do executes the "sasportal.customers.devices.createSigned" call.
  3974  // Any non-2xx status code is an error. Response headers are in either
  3975  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  3976  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3977  // check whether the returned error was because http.StatusNotModified was
  3978  // returned.
  3979  func (c *CustomersDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  3980  	gensupport.SetOptions(c.urlParams_, opts...)
  3981  	res, err := c.doRequest("json")
  3982  	if res != nil && res.StatusCode == http.StatusNotModified {
  3983  		if res.Body != nil {
  3984  			res.Body.Close()
  3985  		}
  3986  		return nil, gensupport.WrapError(&googleapi.Error{
  3987  			Code:   res.StatusCode,
  3988  			Header: res.Header,
  3989  		})
  3990  	}
  3991  	if err != nil {
  3992  		return nil, err
  3993  	}
  3994  	defer googleapi.CloseBody(res)
  3995  	if err := googleapi.CheckResponse(res); err != nil {
  3996  		return nil, gensupport.WrapError(err)
  3997  	}
  3998  	ret := &SasPortalDevice{
  3999  		ServerResponse: googleapi.ServerResponse{
  4000  			Header:         res.Header,
  4001  			HTTPStatusCode: res.StatusCode,
  4002  		},
  4003  	}
  4004  	target := &ret
  4005  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4006  		return nil, err
  4007  	}
  4008  	return ret, nil
  4009  }
  4010  
  4011  type CustomersDevicesDeleteCall struct {
  4012  	s          *Service
  4013  	name       string
  4014  	urlParams_ gensupport.URLParams
  4015  	ctx_       context.Context
  4016  	header_    http.Header
  4017  }
  4018  
  4019  // Delete: Deletes a device.
  4020  //
  4021  // - name: The name of the device.
  4022  func (r *CustomersDevicesService) Delete(name string) *CustomersDevicesDeleteCall {
  4023  	c := &CustomersDevicesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4024  	c.name = name
  4025  	return c
  4026  }
  4027  
  4028  // Fields allows partial responses to be retrieved. See
  4029  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4030  // details.
  4031  func (c *CustomersDevicesDeleteCall) Fields(s ...googleapi.Field) *CustomersDevicesDeleteCall {
  4032  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4033  	return c
  4034  }
  4035  
  4036  // Context sets the context to be used in this call's Do method.
  4037  func (c *CustomersDevicesDeleteCall) Context(ctx context.Context) *CustomersDevicesDeleteCall {
  4038  	c.ctx_ = ctx
  4039  	return c
  4040  }
  4041  
  4042  // Header returns a http.Header that can be modified by the caller to add
  4043  // headers to the request.
  4044  func (c *CustomersDevicesDeleteCall) Header() http.Header {
  4045  	if c.header_ == nil {
  4046  		c.header_ = make(http.Header)
  4047  	}
  4048  	return c.header_
  4049  }
  4050  
  4051  func (c *CustomersDevicesDeleteCall) doRequest(alt string) (*http.Response, error) {
  4052  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  4053  	var body io.Reader = nil
  4054  	c.urlParams_.Set("alt", alt)
  4055  	c.urlParams_.Set("prettyPrint", "false")
  4056  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  4057  	urls += "?" + c.urlParams_.Encode()
  4058  	req, err := http.NewRequest("DELETE", urls, body)
  4059  	if err != nil {
  4060  		return nil, err
  4061  	}
  4062  	req.Header = reqHeaders
  4063  	googleapi.Expand(req.URL, map[string]string{
  4064  		"name": c.name,
  4065  	})
  4066  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4067  }
  4068  
  4069  // Do executes the "sasportal.customers.devices.delete" call.
  4070  // Any non-2xx status code is an error. Response headers are in either
  4071  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  4072  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  4073  // whether the returned error was because http.StatusNotModified was returned.
  4074  func (c *CustomersDevicesDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  4075  	gensupport.SetOptions(c.urlParams_, opts...)
  4076  	res, err := c.doRequest("json")
  4077  	if res != nil && res.StatusCode == http.StatusNotModified {
  4078  		if res.Body != nil {
  4079  			res.Body.Close()
  4080  		}
  4081  		return nil, gensupport.WrapError(&googleapi.Error{
  4082  			Code:   res.StatusCode,
  4083  			Header: res.Header,
  4084  		})
  4085  	}
  4086  	if err != nil {
  4087  		return nil, err
  4088  	}
  4089  	defer googleapi.CloseBody(res)
  4090  	if err := googleapi.CheckResponse(res); err != nil {
  4091  		return nil, gensupport.WrapError(err)
  4092  	}
  4093  	ret := &SasPortalEmpty{
  4094  		ServerResponse: googleapi.ServerResponse{
  4095  			Header:         res.Header,
  4096  			HTTPStatusCode: res.StatusCode,
  4097  		},
  4098  	}
  4099  	target := &ret
  4100  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4101  		return nil, err
  4102  	}
  4103  	return ret, nil
  4104  }
  4105  
  4106  type CustomersDevicesGetCall struct {
  4107  	s            *Service
  4108  	name         string
  4109  	urlParams_   gensupport.URLParams
  4110  	ifNoneMatch_ string
  4111  	ctx_         context.Context
  4112  	header_      http.Header
  4113  }
  4114  
  4115  // Get: Gets details about a device.
  4116  //
  4117  // - name: The name of the device.
  4118  func (r *CustomersDevicesService) Get(name string) *CustomersDevicesGetCall {
  4119  	c := &CustomersDevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4120  	c.name = name
  4121  	return c
  4122  }
  4123  
  4124  // Fields allows partial responses to be retrieved. See
  4125  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4126  // details.
  4127  func (c *CustomersDevicesGetCall) Fields(s ...googleapi.Field) *CustomersDevicesGetCall {
  4128  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4129  	return c
  4130  }
  4131  
  4132  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  4133  // object's ETag matches the given value. This is useful for getting updates
  4134  // only after the object has changed since the last request.
  4135  func (c *CustomersDevicesGetCall) IfNoneMatch(entityTag string) *CustomersDevicesGetCall {
  4136  	c.ifNoneMatch_ = entityTag
  4137  	return c
  4138  }
  4139  
  4140  // Context sets the context to be used in this call's Do method.
  4141  func (c *CustomersDevicesGetCall) Context(ctx context.Context) *CustomersDevicesGetCall {
  4142  	c.ctx_ = ctx
  4143  	return c
  4144  }
  4145  
  4146  // Header returns a http.Header that can be modified by the caller to add
  4147  // headers to the request.
  4148  func (c *CustomersDevicesGetCall) Header() http.Header {
  4149  	if c.header_ == nil {
  4150  		c.header_ = make(http.Header)
  4151  	}
  4152  	return c.header_
  4153  }
  4154  
  4155  func (c *CustomersDevicesGetCall) doRequest(alt string) (*http.Response, error) {
  4156  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  4157  	if c.ifNoneMatch_ != "" {
  4158  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  4159  	}
  4160  	var body io.Reader = nil
  4161  	c.urlParams_.Set("alt", alt)
  4162  	c.urlParams_.Set("prettyPrint", "false")
  4163  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  4164  	urls += "?" + c.urlParams_.Encode()
  4165  	req, err := http.NewRequest("GET", urls, body)
  4166  	if err != nil {
  4167  		return nil, err
  4168  	}
  4169  	req.Header = reqHeaders
  4170  	googleapi.Expand(req.URL, map[string]string{
  4171  		"name": c.name,
  4172  	})
  4173  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4174  }
  4175  
  4176  // Do executes the "sasportal.customers.devices.get" call.
  4177  // Any non-2xx status code is an error. Response headers are in either
  4178  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  4179  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  4180  // check whether the returned error was because http.StatusNotModified was
  4181  // returned.
  4182  func (c *CustomersDevicesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  4183  	gensupport.SetOptions(c.urlParams_, opts...)
  4184  	res, err := c.doRequest("json")
  4185  	if res != nil && res.StatusCode == http.StatusNotModified {
  4186  		if res.Body != nil {
  4187  			res.Body.Close()
  4188  		}
  4189  		return nil, gensupport.WrapError(&googleapi.Error{
  4190  			Code:   res.StatusCode,
  4191  			Header: res.Header,
  4192  		})
  4193  	}
  4194  	if err != nil {
  4195  		return nil, err
  4196  	}
  4197  	defer googleapi.CloseBody(res)
  4198  	if err := googleapi.CheckResponse(res); err != nil {
  4199  		return nil, gensupport.WrapError(err)
  4200  	}
  4201  	ret := &SasPortalDevice{
  4202  		ServerResponse: googleapi.ServerResponse{
  4203  			Header:         res.Header,
  4204  			HTTPStatusCode: res.StatusCode,
  4205  		},
  4206  	}
  4207  	target := &ret
  4208  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4209  		return nil, err
  4210  	}
  4211  	return ret, nil
  4212  }
  4213  
  4214  type CustomersDevicesListCall struct {
  4215  	s            *Service
  4216  	parent       string
  4217  	urlParams_   gensupport.URLParams
  4218  	ifNoneMatch_ string
  4219  	ctx_         context.Context
  4220  	header_      http.Header
  4221  }
  4222  
  4223  // List: Lists devices under a node or customer.
  4224  //
  4225  // - parent: The name of the parent resource.
  4226  func (r *CustomersDevicesService) List(parent string) *CustomersDevicesListCall {
  4227  	c := &CustomersDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4228  	c.parent = parent
  4229  	return c
  4230  }
  4231  
  4232  // Filter sets the optional parameter "filter": The filter expression. The
  4233  // filter should have one of the following formats: "sn=123454" or
  4234  // "display_name=MyDevice". sn corresponds to serial number of the device. The
  4235  // filter is case insensitive.
  4236  func (c *CustomersDevicesListCall) Filter(filter string) *CustomersDevicesListCall {
  4237  	c.urlParams_.Set("filter", filter)
  4238  	return c
  4239  }
  4240  
  4241  // PageSize sets the optional parameter "pageSize": The maximum number of
  4242  // devices to return in the response. If empty or zero, all devices will be
  4243  // listed. Must be in the range [0, 1000].
  4244  func (c *CustomersDevicesListCall) PageSize(pageSize int64) *CustomersDevicesListCall {
  4245  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  4246  	return c
  4247  }
  4248  
  4249  // PageToken sets the optional parameter "pageToken": A pagination token
  4250  // returned from a previous call to ListDevices that indicates where this
  4251  // listing should continue from.
  4252  func (c *CustomersDevicesListCall) PageToken(pageToken string) *CustomersDevicesListCall {
  4253  	c.urlParams_.Set("pageToken", pageToken)
  4254  	return c
  4255  }
  4256  
  4257  // Fields allows partial responses to be retrieved. See
  4258  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4259  // details.
  4260  func (c *CustomersDevicesListCall) Fields(s ...googleapi.Field) *CustomersDevicesListCall {
  4261  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4262  	return c
  4263  }
  4264  
  4265  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  4266  // object's ETag matches the given value. This is useful for getting updates
  4267  // only after the object has changed since the last request.
  4268  func (c *CustomersDevicesListCall) IfNoneMatch(entityTag string) *CustomersDevicesListCall {
  4269  	c.ifNoneMatch_ = entityTag
  4270  	return c
  4271  }
  4272  
  4273  // Context sets the context to be used in this call's Do method.
  4274  func (c *CustomersDevicesListCall) Context(ctx context.Context) *CustomersDevicesListCall {
  4275  	c.ctx_ = ctx
  4276  	return c
  4277  }
  4278  
  4279  // Header returns a http.Header that can be modified by the caller to add
  4280  // headers to the request.
  4281  func (c *CustomersDevicesListCall) Header() http.Header {
  4282  	if c.header_ == nil {
  4283  		c.header_ = make(http.Header)
  4284  	}
  4285  	return c.header_
  4286  }
  4287  
  4288  func (c *CustomersDevicesListCall) doRequest(alt string) (*http.Response, error) {
  4289  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  4290  	if c.ifNoneMatch_ != "" {
  4291  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  4292  	}
  4293  	var body io.Reader = nil
  4294  	c.urlParams_.Set("alt", alt)
  4295  	c.urlParams_.Set("prettyPrint", "false")
  4296  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  4297  	urls += "?" + c.urlParams_.Encode()
  4298  	req, err := http.NewRequest("GET", urls, body)
  4299  	if err != nil {
  4300  		return nil, err
  4301  	}
  4302  	req.Header = reqHeaders
  4303  	googleapi.Expand(req.URL, map[string]string{
  4304  		"parent": c.parent,
  4305  	})
  4306  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4307  }
  4308  
  4309  // Do executes the "sasportal.customers.devices.list" call.
  4310  // Any non-2xx status code is an error. Response headers are in either
  4311  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
  4312  // returned at all) in error.(*googleapi.Error).Header. Use
  4313  // googleapi.IsNotModified to check whether the returned error was because
  4314  // http.StatusNotModified was returned.
  4315  func (c *CustomersDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
  4316  	gensupport.SetOptions(c.urlParams_, opts...)
  4317  	res, err := c.doRequest("json")
  4318  	if res != nil && res.StatusCode == http.StatusNotModified {
  4319  		if res.Body != nil {
  4320  			res.Body.Close()
  4321  		}
  4322  		return nil, gensupport.WrapError(&googleapi.Error{
  4323  			Code:   res.StatusCode,
  4324  			Header: res.Header,
  4325  		})
  4326  	}
  4327  	if err != nil {
  4328  		return nil, err
  4329  	}
  4330  	defer googleapi.CloseBody(res)
  4331  	if err := googleapi.CheckResponse(res); err != nil {
  4332  		return nil, gensupport.WrapError(err)
  4333  	}
  4334  	ret := &SasPortalListDevicesResponse{
  4335  		ServerResponse: googleapi.ServerResponse{
  4336  			Header:         res.Header,
  4337  			HTTPStatusCode: res.StatusCode,
  4338  		},
  4339  	}
  4340  	target := &ret
  4341  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4342  		return nil, err
  4343  	}
  4344  	return ret, nil
  4345  }
  4346  
  4347  // Pages invokes f for each page of results.
  4348  // A non-nil error returned from f will halt the iteration.
  4349  // The provided context supersedes any context provided to the Context method.
  4350  func (c *CustomersDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
  4351  	c.ctx_ = ctx
  4352  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  4353  	for {
  4354  		x, err := c.Do()
  4355  		if err != nil {
  4356  			return err
  4357  		}
  4358  		if err := f(x); err != nil {
  4359  			return err
  4360  		}
  4361  		if x.NextPageToken == "" {
  4362  			return nil
  4363  		}
  4364  		c.PageToken(x.NextPageToken)
  4365  	}
  4366  }
  4367  
  4368  type CustomersDevicesMoveCall struct {
  4369  	s                          *Service
  4370  	name                       string
  4371  	sasportalmovedevicerequest *SasPortalMoveDeviceRequest
  4372  	urlParams_                 gensupport.URLParams
  4373  	ctx_                       context.Context
  4374  	header_                    http.Header
  4375  }
  4376  
  4377  // Move: Moves a device under another node or customer.
  4378  //
  4379  // - name: The name of the device to move.
  4380  func (r *CustomersDevicesService) Move(name string, sasportalmovedevicerequest *SasPortalMoveDeviceRequest) *CustomersDevicesMoveCall {
  4381  	c := &CustomersDevicesMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4382  	c.name = name
  4383  	c.sasportalmovedevicerequest = sasportalmovedevicerequest
  4384  	return c
  4385  }
  4386  
  4387  // Fields allows partial responses to be retrieved. See
  4388  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4389  // details.
  4390  func (c *CustomersDevicesMoveCall) Fields(s ...googleapi.Field) *CustomersDevicesMoveCall {
  4391  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4392  	return c
  4393  }
  4394  
  4395  // Context sets the context to be used in this call's Do method.
  4396  func (c *CustomersDevicesMoveCall) Context(ctx context.Context) *CustomersDevicesMoveCall {
  4397  	c.ctx_ = ctx
  4398  	return c
  4399  }
  4400  
  4401  // Header returns a http.Header that can be modified by the caller to add
  4402  // headers to the request.
  4403  func (c *CustomersDevicesMoveCall) Header() http.Header {
  4404  	if c.header_ == nil {
  4405  		c.header_ = make(http.Header)
  4406  	}
  4407  	return c.header_
  4408  }
  4409  
  4410  func (c *CustomersDevicesMoveCall) doRequest(alt string) (*http.Response, error) {
  4411  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  4412  	var body io.Reader = nil
  4413  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovedevicerequest)
  4414  	if err != nil {
  4415  		return nil, err
  4416  	}
  4417  	c.urlParams_.Set("alt", alt)
  4418  	c.urlParams_.Set("prettyPrint", "false")
  4419  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  4420  	urls += "?" + c.urlParams_.Encode()
  4421  	req, err := http.NewRequest("POST", urls, body)
  4422  	if err != nil {
  4423  		return nil, err
  4424  	}
  4425  	req.Header = reqHeaders
  4426  	googleapi.Expand(req.URL, map[string]string{
  4427  		"name": c.name,
  4428  	})
  4429  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4430  }
  4431  
  4432  // Do executes the "sasportal.customers.devices.move" call.
  4433  // Any non-2xx status code is an error. Response headers are in either
  4434  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  4435  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  4436  // check whether the returned error was because http.StatusNotModified was
  4437  // returned.
  4438  func (c *CustomersDevicesMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  4439  	gensupport.SetOptions(c.urlParams_, opts...)
  4440  	res, err := c.doRequest("json")
  4441  	if res != nil && res.StatusCode == http.StatusNotModified {
  4442  		if res.Body != nil {
  4443  			res.Body.Close()
  4444  		}
  4445  		return nil, gensupport.WrapError(&googleapi.Error{
  4446  			Code:   res.StatusCode,
  4447  			Header: res.Header,
  4448  		})
  4449  	}
  4450  	if err != nil {
  4451  		return nil, err
  4452  	}
  4453  	defer googleapi.CloseBody(res)
  4454  	if err := googleapi.CheckResponse(res); err != nil {
  4455  		return nil, gensupport.WrapError(err)
  4456  	}
  4457  	ret := &SasPortalOperation{
  4458  		ServerResponse: googleapi.ServerResponse{
  4459  			Header:         res.Header,
  4460  			HTTPStatusCode: res.StatusCode,
  4461  		},
  4462  	}
  4463  	target := &ret
  4464  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4465  		return nil, err
  4466  	}
  4467  	return ret, nil
  4468  }
  4469  
  4470  type CustomersDevicesPatchCall struct {
  4471  	s               *Service
  4472  	name            string
  4473  	sasportaldevice *SasPortalDevice
  4474  	urlParams_      gensupport.URLParams
  4475  	ctx_            context.Context
  4476  	header_         http.Header
  4477  }
  4478  
  4479  // Patch: Updates a device.
  4480  //
  4481  // - name: Output only. The resource path name.
  4482  func (r *CustomersDevicesService) Patch(name string, sasportaldevice *SasPortalDevice) *CustomersDevicesPatchCall {
  4483  	c := &CustomersDevicesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4484  	c.name = name
  4485  	c.sasportaldevice = sasportaldevice
  4486  	return c
  4487  }
  4488  
  4489  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  4490  func (c *CustomersDevicesPatchCall) UpdateMask(updateMask string) *CustomersDevicesPatchCall {
  4491  	c.urlParams_.Set("updateMask", updateMask)
  4492  	return c
  4493  }
  4494  
  4495  // Fields allows partial responses to be retrieved. See
  4496  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4497  // details.
  4498  func (c *CustomersDevicesPatchCall) Fields(s ...googleapi.Field) *CustomersDevicesPatchCall {
  4499  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4500  	return c
  4501  }
  4502  
  4503  // Context sets the context to be used in this call's Do method.
  4504  func (c *CustomersDevicesPatchCall) Context(ctx context.Context) *CustomersDevicesPatchCall {
  4505  	c.ctx_ = ctx
  4506  	return c
  4507  }
  4508  
  4509  // Header returns a http.Header that can be modified by the caller to add
  4510  // headers to the request.
  4511  func (c *CustomersDevicesPatchCall) Header() http.Header {
  4512  	if c.header_ == nil {
  4513  		c.header_ = make(http.Header)
  4514  	}
  4515  	return c.header_
  4516  }
  4517  
  4518  func (c *CustomersDevicesPatchCall) doRequest(alt string) (*http.Response, error) {
  4519  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  4520  	var body io.Reader = nil
  4521  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  4522  	if err != nil {
  4523  		return nil, err
  4524  	}
  4525  	c.urlParams_.Set("alt", alt)
  4526  	c.urlParams_.Set("prettyPrint", "false")
  4527  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  4528  	urls += "?" + c.urlParams_.Encode()
  4529  	req, err := http.NewRequest("PATCH", urls, body)
  4530  	if err != nil {
  4531  		return nil, err
  4532  	}
  4533  	req.Header = reqHeaders
  4534  	googleapi.Expand(req.URL, map[string]string{
  4535  		"name": c.name,
  4536  	})
  4537  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4538  }
  4539  
  4540  // Do executes the "sasportal.customers.devices.patch" call.
  4541  // Any non-2xx status code is an error. Response headers are in either
  4542  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  4543  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  4544  // check whether the returned error was because http.StatusNotModified was
  4545  // returned.
  4546  func (c *CustomersDevicesPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  4547  	gensupport.SetOptions(c.urlParams_, opts...)
  4548  	res, err := c.doRequest("json")
  4549  	if res != nil && res.StatusCode == http.StatusNotModified {
  4550  		if res.Body != nil {
  4551  			res.Body.Close()
  4552  		}
  4553  		return nil, gensupport.WrapError(&googleapi.Error{
  4554  			Code:   res.StatusCode,
  4555  			Header: res.Header,
  4556  		})
  4557  	}
  4558  	if err != nil {
  4559  		return nil, err
  4560  	}
  4561  	defer googleapi.CloseBody(res)
  4562  	if err := googleapi.CheckResponse(res); err != nil {
  4563  		return nil, gensupport.WrapError(err)
  4564  	}
  4565  	ret := &SasPortalDevice{
  4566  		ServerResponse: googleapi.ServerResponse{
  4567  			Header:         res.Header,
  4568  			HTTPStatusCode: res.StatusCode,
  4569  		},
  4570  	}
  4571  	target := &ret
  4572  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4573  		return nil, err
  4574  	}
  4575  	return ret, nil
  4576  }
  4577  
  4578  type CustomersDevicesSignDeviceCall struct {
  4579  	s                          *Service
  4580  	name                       string
  4581  	sasportalsigndevicerequest *SasPortalSignDeviceRequest
  4582  	urlParams_                 gensupport.URLParams
  4583  	ctx_                       context.Context
  4584  	header_                    http.Header
  4585  }
  4586  
  4587  // SignDevice: Signs a device.
  4588  //
  4589  // - name: Output only. The resource path name.
  4590  func (r *CustomersDevicesService) SignDevice(name string, sasportalsigndevicerequest *SasPortalSignDeviceRequest) *CustomersDevicesSignDeviceCall {
  4591  	c := &CustomersDevicesSignDeviceCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4592  	c.name = name
  4593  	c.sasportalsigndevicerequest = sasportalsigndevicerequest
  4594  	return c
  4595  }
  4596  
  4597  // Fields allows partial responses to be retrieved. See
  4598  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4599  // details.
  4600  func (c *CustomersDevicesSignDeviceCall) Fields(s ...googleapi.Field) *CustomersDevicesSignDeviceCall {
  4601  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4602  	return c
  4603  }
  4604  
  4605  // Context sets the context to be used in this call's Do method.
  4606  func (c *CustomersDevicesSignDeviceCall) Context(ctx context.Context) *CustomersDevicesSignDeviceCall {
  4607  	c.ctx_ = ctx
  4608  	return c
  4609  }
  4610  
  4611  // Header returns a http.Header that can be modified by the caller to add
  4612  // headers to the request.
  4613  func (c *CustomersDevicesSignDeviceCall) Header() http.Header {
  4614  	if c.header_ == nil {
  4615  		c.header_ = make(http.Header)
  4616  	}
  4617  	return c.header_
  4618  }
  4619  
  4620  func (c *CustomersDevicesSignDeviceCall) doRequest(alt string) (*http.Response, error) {
  4621  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  4622  	var body io.Reader = nil
  4623  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalsigndevicerequest)
  4624  	if err != nil {
  4625  		return nil, err
  4626  	}
  4627  	c.urlParams_.Set("alt", alt)
  4628  	c.urlParams_.Set("prettyPrint", "false")
  4629  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:signDevice")
  4630  	urls += "?" + c.urlParams_.Encode()
  4631  	req, err := http.NewRequest("POST", urls, body)
  4632  	if err != nil {
  4633  		return nil, err
  4634  	}
  4635  	req.Header = reqHeaders
  4636  	googleapi.Expand(req.URL, map[string]string{
  4637  		"name": c.name,
  4638  	})
  4639  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4640  }
  4641  
  4642  // Do executes the "sasportal.customers.devices.signDevice" call.
  4643  // Any non-2xx status code is an error. Response headers are in either
  4644  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  4645  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  4646  // whether the returned error was because http.StatusNotModified was returned.
  4647  func (c *CustomersDevicesSignDeviceCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  4648  	gensupport.SetOptions(c.urlParams_, opts...)
  4649  	res, err := c.doRequest("json")
  4650  	if res != nil && res.StatusCode == http.StatusNotModified {
  4651  		if res.Body != nil {
  4652  			res.Body.Close()
  4653  		}
  4654  		return nil, gensupport.WrapError(&googleapi.Error{
  4655  			Code:   res.StatusCode,
  4656  			Header: res.Header,
  4657  		})
  4658  	}
  4659  	if err != nil {
  4660  		return nil, err
  4661  	}
  4662  	defer googleapi.CloseBody(res)
  4663  	if err := googleapi.CheckResponse(res); err != nil {
  4664  		return nil, gensupport.WrapError(err)
  4665  	}
  4666  	ret := &SasPortalEmpty{
  4667  		ServerResponse: googleapi.ServerResponse{
  4668  			Header:         res.Header,
  4669  			HTTPStatusCode: res.StatusCode,
  4670  		},
  4671  	}
  4672  	target := &ret
  4673  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4674  		return nil, err
  4675  	}
  4676  	return ret, nil
  4677  }
  4678  
  4679  type CustomersDevicesUpdateSignedCall struct {
  4680  	s                                  *Service
  4681  	name                               string
  4682  	sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest
  4683  	urlParams_                         gensupport.URLParams
  4684  	ctx_                               context.Context
  4685  	header_                            http.Header
  4686  }
  4687  
  4688  // UpdateSigned: Updates a signed device.
  4689  //
  4690  // - name: The name of the device to update.
  4691  func (r *CustomersDevicesService) UpdateSigned(name string, sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest) *CustomersDevicesUpdateSignedCall {
  4692  	c := &CustomersDevicesUpdateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4693  	c.name = name
  4694  	c.sasportalupdatesigneddevicerequest = sasportalupdatesigneddevicerequest
  4695  	return c
  4696  }
  4697  
  4698  // Fields allows partial responses to be retrieved. See
  4699  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4700  // details.
  4701  func (c *CustomersDevicesUpdateSignedCall) Fields(s ...googleapi.Field) *CustomersDevicesUpdateSignedCall {
  4702  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4703  	return c
  4704  }
  4705  
  4706  // Context sets the context to be used in this call's Do method.
  4707  func (c *CustomersDevicesUpdateSignedCall) Context(ctx context.Context) *CustomersDevicesUpdateSignedCall {
  4708  	c.ctx_ = ctx
  4709  	return c
  4710  }
  4711  
  4712  // Header returns a http.Header that can be modified by the caller to add
  4713  // headers to the request.
  4714  func (c *CustomersDevicesUpdateSignedCall) Header() http.Header {
  4715  	if c.header_ == nil {
  4716  		c.header_ = make(http.Header)
  4717  	}
  4718  	return c.header_
  4719  }
  4720  
  4721  func (c *CustomersDevicesUpdateSignedCall) doRequest(alt string) (*http.Response, error) {
  4722  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  4723  	var body io.Reader = nil
  4724  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalupdatesigneddevicerequest)
  4725  	if err != nil {
  4726  		return nil, err
  4727  	}
  4728  	c.urlParams_.Set("alt", alt)
  4729  	c.urlParams_.Set("prettyPrint", "false")
  4730  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:updateSigned")
  4731  	urls += "?" + c.urlParams_.Encode()
  4732  	req, err := http.NewRequest("PATCH", urls, body)
  4733  	if err != nil {
  4734  		return nil, err
  4735  	}
  4736  	req.Header = reqHeaders
  4737  	googleapi.Expand(req.URL, map[string]string{
  4738  		"name": c.name,
  4739  	})
  4740  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4741  }
  4742  
  4743  // Do executes the "sasportal.customers.devices.updateSigned" call.
  4744  // Any non-2xx status code is an error. Response headers are in either
  4745  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  4746  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  4747  // check whether the returned error was because http.StatusNotModified was
  4748  // returned.
  4749  func (c *CustomersDevicesUpdateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  4750  	gensupport.SetOptions(c.urlParams_, opts...)
  4751  	res, err := c.doRequest("json")
  4752  	if res != nil && res.StatusCode == http.StatusNotModified {
  4753  		if res.Body != nil {
  4754  			res.Body.Close()
  4755  		}
  4756  		return nil, gensupport.WrapError(&googleapi.Error{
  4757  			Code:   res.StatusCode,
  4758  			Header: res.Header,
  4759  		})
  4760  	}
  4761  	if err != nil {
  4762  		return nil, err
  4763  	}
  4764  	defer googleapi.CloseBody(res)
  4765  	if err := googleapi.CheckResponse(res); err != nil {
  4766  		return nil, gensupport.WrapError(err)
  4767  	}
  4768  	ret := &SasPortalDevice{
  4769  		ServerResponse: googleapi.ServerResponse{
  4770  			Header:         res.Header,
  4771  			HTTPStatusCode: res.StatusCode,
  4772  		},
  4773  	}
  4774  	target := &ret
  4775  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4776  		return nil, err
  4777  	}
  4778  	return ret, nil
  4779  }
  4780  
  4781  type CustomersNodesCreateCall struct {
  4782  	s             *Service
  4783  	parent        string
  4784  	sasportalnode *SasPortalNode
  4785  	urlParams_    gensupport.URLParams
  4786  	ctx_          context.Context
  4787  	header_       http.Header
  4788  }
  4789  
  4790  // Create: Creates a new node.
  4791  //
  4792  // - parent: The parent resource name where the node is to be created.
  4793  func (r *CustomersNodesService) Create(parent string, sasportalnode *SasPortalNode) *CustomersNodesCreateCall {
  4794  	c := &CustomersNodesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4795  	c.parent = parent
  4796  	c.sasportalnode = sasportalnode
  4797  	return c
  4798  }
  4799  
  4800  // Fields allows partial responses to be retrieved. See
  4801  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4802  // details.
  4803  func (c *CustomersNodesCreateCall) Fields(s ...googleapi.Field) *CustomersNodesCreateCall {
  4804  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4805  	return c
  4806  }
  4807  
  4808  // Context sets the context to be used in this call's Do method.
  4809  func (c *CustomersNodesCreateCall) Context(ctx context.Context) *CustomersNodesCreateCall {
  4810  	c.ctx_ = ctx
  4811  	return c
  4812  }
  4813  
  4814  // Header returns a http.Header that can be modified by the caller to add
  4815  // headers to the request.
  4816  func (c *CustomersNodesCreateCall) Header() http.Header {
  4817  	if c.header_ == nil {
  4818  		c.header_ = make(http.Header)
  4819  	}
  4820  	return c.header_
  4821  }
  4822  
  4823  func (c *CustomersNodesCreateCall) doRequest(alt string) (*http.Response, error) {
  4824  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  4825  	var body io.Reader = nil
  4826  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
  4827  	if err != nil {
  4828  		return nil, err
  4829  	}
  4830  	c.urlParams_.Set("alt", alt)
  4831  	c.urlParams_.Set("prettyPrint", "false")
  4832  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  4833  	urls += "?" + c.urlParams_.Encode()
  4834  	req, err := http.NewRequest("POST", urls, body)
  4835  	if err != nil {
  4836  		return nil, err
  4837  	}
  4838  	req.Header = reqHeaders
  4839  	googleapi.Expand(req.URL, map[string]string{
  4840  		"parent": c.parent,
  4841  	})
  4842  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4843  }
  4844  
  4845  // Do executes the "sasportal.customers.nodes.create" call.
  4846  // Any non-2xx status code is an error. Response headers are in either
  4847  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  4848  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  4849  // whether the returned error was because http.StatusNotModified was returned.
  4850  func (c *CustomersNodesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  4851  	gensupport.SetOptions(c.urlParams_, opts...)
  4852  	res, err := c.doRequest("json")
  4853  	if res != nil && res.StatusCode == http.StatusNotModified {
  4854  		if res.Body != nil {
  4855  			res.Body.Close()
  4856  		}
  4857  		return nil, gensupport.WrapError(&googleapi.Error{
  4858  			Code:   res.StatusCode,
  4859  			Header: res.Header,
  4860  		})
  4861  	}
  4862  	if err != nil {
  4863  		return nil, err
  4864  	}
  4865  	defer googleapi.CloseBody(res)
  4866  	if err := googleapi.CheckResponse(res); err != nil {
  4867  		return nil, gensupport.WrapError(err)
  4868  	}
  4869  	ret := &SasPortalNode{
  4870  		ServerResponse: googleapi.ServerResponse{
  4871  			Header:         res.Header,
  4872  			HTTPStatusCode: res.StatusCode,
  4873  		},
  4874  	}
  4875  	target := &ret
  4876  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4877  		return nil, err
  4878  	}
  4879  	return ret, nil
  4880  }
  4881  
  4882  type CustomersNodesDeleteCall struct {
  4883  	s          *Service
  4884  	name       string
  4885  	urlParams_ gensupport.URLParams
  4886  	ctx_       context.Context
  4887  	header_    http.Header
  4888  }
  4889  
  4890  // Delete: Deletes a node.
  4891  //
  4892  // - name: The name of the node.
  4893  func (r *CustomersNodesService) Delete(name string) *CustomersNodesDeleteCall {
  4894  	c := &CustomersNodesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4895  	c.name = name
  4896  	return c
  4897  }
  4898  
  4899  // Fields allows partial responses to be retrieved. See
  4900  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4901  // details.
  4902  func (c *CustomersNodesDeleteCall) Fields(s ...googleapi.Field) *CustomersNodesDeleteCall {
  4903  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  4904  	return c
  4905  }
  4906  
  4907  // Context sets the context to be used in this call's Do method.
  4908  func (c *CustomersNodesDeleteCall) Context(ctx context.Context) *CustomersNodesDeleteCall {
  4909  	c.ctx_ = ctx
  4910  	return c
  4911  }
  4912  
  4913  // Header returns a http.Header that can be modified by the caller to add
  4914  // headers to the request.
  4915  func (c *CustomersNodesDeleteCall) Header() http.Header {
  4916  	if c.header_ == nil {
  4917  		c.header_ = make(http.Header)
  4918  	}
  4919  	return c.header_
  4920  }
  4921  
  4922  func (c *CustomersNodesDeleteCall) doRequest(alt string) (*http.Response, error) {
  4923  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  4924  	var body io.Reader = nil
  4925  	c.urlParams_.Set("alt", alt)
  4926  	c.urlParams_.Set("prettyPrint", "false")
  4927  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  4928  	urls += "?" + c.urlParams_.Encode()
  4929  	req, err := http.NewRequest("DELETE", urls, body)
  4930  	if err != nil {
  4931  		return nil, err
  4932  	}
  4933  	req.Header = reqHeaders
  4934  	googleapi.Expand(req.URL, map[string]string{
  4935  		"name": c.name,
  4936  	})
  4937  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  4938  }
  4939  
  4940  // Do executes the "sasportal.customers.nodes.delete" call.
  4941  // Any non-2xx status code is an error. Response headers are in either
  4942  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  4943  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  4944  // whether the returned error was because http.StatusNotModified was returned.
  4945  func (c *CustomersNodesDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  4946  	gensupport.SetOptions(c.urlParams_, opts...)
  4947  	res, err := c.doRequest("json")
  4948  	if res != nil && res.StatusCode == http.StatusNotModified {
  4949  		if res.Body != nil {
  4950  			res.Body.Close()
  4951  		}
  4952  		return nil, gensupport.WrapError(&googleapi.Error{
  4953  			Code:   res.StatusCode,
  4954  			Header: res.Header,
  4955  		})
  4956  	}
  4957  	if err != nil {
  4958  		return nil, err
  4959  	}
  4960  	defer googleapi.CloseBody(res)
  4961  	if err := googleapi.CheckResponse(res); err != nil {
  4962  		return nil, gensupport.WrapError(err)
  4963  	}
  4964  	ret := &SasPortalEmpty{
  4965  		ServerResponse: googleapi.ServerResponse{
  4966  			Header:         res.Header,
  4967  			HTTPStatusCode: res.StatusCode,
  4968  		},
  4969  	}
  4970  	target := &ret
  4971  	if err := gensupport.DecodeResponse(target, res); err != nil {
  4972  		return nil, err
  4973  	}
  4974  	return ret, nil
  4975  }
  4976  
  4977  type CustomersNodesGetCall struct {
  4978  	s            *Service
  4979  	name         string
  4980  	urlParams_   gensupport.URLParams
  4981  	ifNoneMatch_ string
  4982  	ctx_         context.Context
  4983  	header_      http.Header
  4984  }
  4985  
  4986  // Get: Returns a requested node.
  4987  //
  4988  // - name: The name of the node.
  4989  func (r *CustomersNodesService) Get(name string) *CustomersNodesGetCall {
  4990  	c := &CustomersNodesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  4991  	c.name = name
  4992  	return c
  4993  }
  4994  
  4995  // Fields allows partial responses to be retrieved. See
  4996  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  4997  // details.
  4998  func (c *CustomersNodesGetCall) Fields(s ...googleapi.Field) *CustomersNodesGetCall {
  4999  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5000  	return c
  5001  }
  5002  
  5003  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  5004  // object's ETag matches the given value. This is useful for getting updates
  5005  // only after the object has changed since the last request.
  5006  func (c *CustomersNodesGetCall) IfNoneMatch(entityTag string) *CustomersNodesGetCall {
  5007  	c.ifNoneMatch_ = entityTag
  5008  	return c
  5009  }
  5010  
  5011  // Context sets the context to be used in this call's Do method.
  5012  func (c *CustomersNodesGetCall) Context(ctx context.Context) *CustomersNodesGetCall {
  5013  	c.ctx_ = ctx
  5014  	return c
  5015  }
  5016  
  5017  // Header returns a http.Header that can be modified by the caller to add
  5018  // headers to the request.
  5019  func (c *CustomersNodesGetCall) Header() http.Header {
  5020  	if c.header_ == nil {
  5021  		c.header_ = make(http.Header)
  5022  	}
  5023  	return c.header_
  5024  }
  5025  
  5026  func (c *CustomersNodesGetCall) doRequest(alt string) (*http.Response, error) {
  5027  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  5028  	if c.ifNoneMatch_ != "" {
  5029  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  5030  	}
  5031  	var body io.Reader = nil
  5032  	c.urlParams_.Set("alt", alt)
  5033  	c.urlParams_.Set("prettyPrint", "false")
  5034  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  5035  	urls += "?" + c.urlParams_.Encode()
  5036  	req, err := http.NewRequest("GET", urls, body)
  5037  	if err != nil {
  5038  		return nil, err
  5039  	}
  5040  	req.Header = reqHeaders
  5041  	googleapi.Expand(req.URL, map[string]string{
  5042  		"name": c.name,
  5043  	})
  5044  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5045  }
  5046  
  5047  // Do executes the "sasportal.customers.nodes.get" call.
  5048  // Any non-2xx status code is an error. Response headers are in either
  5049  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  5050  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  5051  // whether the returned error was because http.StatusNotModified was returned.
  5052  func (c *CustomersNodesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  5053  	gensupport.SetOptions(c.urlParams_, opts...)
  5054  	res, err := c.doRequest("json")
  5055  	if res != nil && res.StatusCode == http.StatusNotModified {
  5056  		if res.Body != nil {
  5057  			res.Body.Close()
  5058  		}
  5059  		return nil, gensupport.WrapError(&googleapi.Error{
  5060  			Code:   res.StatusCode,
  5061  			Header: res.Header,
  5062  		})
  5063  	}
  5064  	if err != nil {
  5065  		return nil, err
  5066  	}
  5067  	defer googleapi.CloseBody(res)
  5068  	if err := googleapi.CheckResponse(res); err != nil {
  5069  		return nil, gensupport.WrapError(err)
  5070  	}
  5071  	ret := &SasPortalNode{
  5072  		ServerResponse: googleapi.ServerResponse{
  5073  			Header:         res.Header,
  5074  			HTTPStatusCode: res.StatusCode,
  5075  		},
  5076  	}
  5077  	target := &ret
  5078  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5079  		return nil, err
  5080  	}
  5081  	return ret, nil
  5082  }
  5083  
  5084  type CustomersNodesListCall struct {
  5085  	s            *Service
  5086  	parent       string
  5087  	urlParams_   gensupport.URLParams
  5088  	ifNoneMatch_ string
  5089  	ctx_         context.Context
  5090  	header_      http.Header
  5091  }
  5092  
  5093  // List: Lists nodes.
  5094  //
  5095  // - parent: The parent resource name, for example, "nodes/1".
  5096  func (r *CustomersNodesService) List(parent string) *CustomersNodesListCall {
  5097  	c := &CustomersNodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5098  	c.parent = parent
  5099  	return c
  5100  }
  5101  
  5102  // Filter sets the optional parameter "filter": The filter expression. The
  5103  // filter should have the following format: "DIRECT_CHILDREN" or format:
  5104  // "direct_children". The filter is case insensitive. If empty, then no nodes
  5105  // are filtered.
  5106  func (c *CustomersNodesListCall) Filter(filter string) *CustomersNodesListCall {
  5107  	c.urlParams_.Set("filter", filter)
  5108  	return c
  5109  }
  5110  
  5111  // PageSize sets the optional parameter "pageSize": The maximum number of nodes
  5112  // to return in the response.
  5113  func (c *CustomersNodesListCall) PageSize(pageSize int64) *CustomersNodesListCall {
  5114  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  5115  	return c
  5116  }
  5117  
  5118  // PageToken sets the optional parameter "pageToken": A pagination token
  5119  // returned from a previous call to ListNodes that indicates where this listing
  5120  // should continue from.
  5121  func (c *CustomersNodesListCall) PageToken(pageToken string) *CustomersNodesListCall {
  5122  	c.urlParams_.Set("pageToken", pageToken)
  5123  	return c
  5124  }
  5125  
  5126  // Fields allows partial responses to be retrieved. See
  5127  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5128  // details.
  5129  func (c *CustomersNodesListCall) Fields(s ...googleapi.Field) *CustomersNodesListCall {
  5130  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5131  	return c
  5132  }
  5133  
  5134  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  5135  // object's ETag matches the given value. This is useful for getting updates
  5136  // only after the object has changed since the last request.
  5137  func (c *CustomersNodesListCall) IfNoneMatch(entityTag string) *CustomersNodesListCall {
  5138  	c.ifNoneMatch_ = entityTag
  5139  	return c
  5140  }
  5141  
  5142  // Context sets the context to be used in this call's Do method.
  5143  func (c *CustomersNodesListCall) Context(ctx context.Context) *CustomersNodesListCall {
  5144  	c.ctx_ = ctx
  5145  	return c
  5146  }
  5147  
  5148  // Header returns a http.Header that can be modified by the caller to add
  5149  // headers to the request.
  5150  func (c *CustomersNodesListCall) Header() http.Header {
  5151  	if c.header_ == nil {
  5152  		c.header_ = make(http.Header)
  5153  	}
  5154  	return c.header_
  5155  }
  5156  
  5157  func (c *CustomersNodesListCall) doRequest(alt string) (*http.Response, error) {
  5158  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  5159  	if c.ifNoneMatch_ != "" {
  5160  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  5161  	}
  5162  	var body io.Reader = nil
  5163  	c.urlParams_.Set("alt", alt)
  5164  	c.urlParams_.Set("prettyPrint", "false")
  5165  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  5166  	urls += "?" + c.urlParams_.Encode()
  5167  	req, err := http.NewRequest("GET", urls, body)
  5168  	if err != nil {
  5169  		return nil, err
  5170  	}
  5171  	req.Header = reqHeaders
  5172  	googleapi.Expand(req.URL, map[string]string{
  5173  		"parent": c.parent,
  5174  	})
  5175  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5176  }
  5177  
  5178  // Do executes the "sasportal.customers.nodes.list" call.
  5179  // Any non-2xx status code is an error. Response headers are in either
  5180  // *SasPortalListNodesResponse.ServerResponse.Header or (if a response was
  5181  // returned at all) in error.(*googleapi.Error).Header. Use
  5182  // googleapi.IsNotModified to check whether the returned error was because
  5183  // http.StatusNotModified was returned.
  5184  func (c *CustomersNodesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListNodesResponse, error) {
  5185  	gensupport.SetOptions(c.urlParams_, opts...)
  5186  	res, err := c.doRequest("json")
  5187  	if res != nil && res.StatusCode == http.StatusNotModified {
  5188  		if res.Body != nil {
  5189  			res.Body.Close()
  5190  		}
  5191  		return nil, gensupport.WrapError(&googleapi.Error{
  5192  			Code:   res.StatusCode,
  5193  			Header: res.Header,
  5194  		})
  5195  	}
  5196  	if err != nil {
  5197  		return nil, err
  5198  	}
  5199  	defer googleapi.CloseBody(res)
  5200  	if err := googleapi.CheckResponse(res); err != nil {
  5201  		return nil, gensupport.WrapError(err)
  5202  	}
  5203  	ret := &SasPortalListNodesResponse{
  5204  		ServerResponse: googleapi.ServerResponse{
  5205  			Header:         res.Header,
  5206  			HTTPStatusCode: res.StatusCode,
  5207  		},
  5208  	}
  5209  	target := &ret
  5210  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5211  		return nil, err
  5212  	}
  5213  	return ret, nil
  5214  }
  5215  
  5216  // Pages invokes f for each page of results.
  5217  // A non-nil error returned from f will halt the iteration.
  5218  // The provided context supersedes any context provided to the Context method.
  5219  func (c *CustomersNodesListCall) Pages(ctx context.Context, f func(*SasPortalListNodesResponse) error) error {
  5220  	c.ctx_ = ctx
  5221  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  5222  	for {
  5223  		x, err := c.Do()
  5224  		if err != nil {
  5225  			return err
  5226  		}
  5227  		if err := f(x); err != nil {
  5228  			return err
  5229  		}
  5230  		if x.NextPageToken == "" {
  5231  			return nil
  5232  		}
  5233  		c.PageToken(x.NextPageToken)
  5234  	}
  5235  }
  5236  
  5237  type CustomersNodesMoveCall struct {
  5238  	s                        *Service
  5239  	name                     string
  5240  	sasportalmovenoderequest *SasPortalMoveNodeRequest
  5241  	urlParams_               gensupport.URLParams
  5242  	ctx_                     context.Context
  5243  	header_                  http.Header
  5244  }
  5245  
  5246  // Move: Moves a node under another node or customer.
  5247  //
  5248  // - name: The name of the node to move.
  5249  func (r *CustomersNodesService) Move(name string, sasportalmovenoderequest *SasPortalMoveNodeRequest) *CustomersNodesMoveCall {
  5250  	c := &CustomersNodesMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5251  	c.name = name
  5252  	c.sasportalmovenoderequest = sasportalmovenoderequest
  5253  	return c
  5254  }
  5255  
  5256  // Fields allows partial responses to be retrieved. See
  5257  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5258  // details.
  5259  func (c *CustomersNodesMoveCall) Fields(s ...googleapi.Field) *CustomersNodesMoveCall {
  5260  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5261  	return c
  5262  }
  5263  
  5264  // Context sets the context to be used in this call's Do method.
  5265  func (c *CustomersNodesMoveCall) Context(ctx context.Context) *CustomersNodesMoveCall {
  5266  	c.ctx_ = ctx
  5267  	return c
  5268  }
  5269  
  5270  // Header returns a http.Header that can be modified by the caller to add
  5271  // headers to the request.
  5272  func (c *CustomersNodesMoveCall) Header() http.Header {
  5273  	if c.header_ == nil {
  5274  		c.header_ = make(http.Header)
  5275  	}
  5276  	return c.header_
  5277  }
  5278  
  5279  func (c *CustomersNodesMoveCall) doRequest(alt string) (*http.Response, error) {
  5280  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  5281  	var body io.Reader = nil
  5282  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovenoderequest)
  5283  	if err != nil {
  5284  		return nil, err
  5285  	}
  5286  	c.urlParams_.Set("alt", alt)
  5287  	c.urlParams_.Set("prettyPrint", "false")
  5288  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  5289  	urls += "?" + c.urlParams_.Encode()
  5290  	req, err := http.NewRequest("POST", urls, body)
  5291  	if err != nil {
  5292  		return nil, err
  5293  	}
  5294  	req.Header = reqHeaders
  5295  	googleapi.Expand(req.URL, map[string]string{
  5296  		"name": c.name,
  5297  	})
  5298  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5299  }
  5300  
  5301  // Do executes the "sasportal.customers.nodes.move" call.
  5302  // Any non-2xx status code is an error. Response headers are in either
  5303  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  5304  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  5305  // check whether the returned error was because http.StatusNotModified was
  5306  // returned.
  5307  func (c *CustomersNodesMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  5308  	gensupport.SetOptions(c.urlParams_, opts...)
  5309  	res, err := c.doRequest("json")
  5310  	if res != nil && res.StatusCode == http.StatusNotModified {
  5311  		if res.Body != nil {
  5312  			res.Body.Close()
  5313  		}
  5314  		return nil, gensupport.WrapError(&googleapi.Error{
  5315  			Code:   res.StatusCode,
  5316  			Header: res.Header,
  5317  		})
  5318  	}
  5319  	if err != nil {
  5320  		return nil, err
  5321  	}
  5322  	defer googleapi.CloseBody(res)
  5323  	if err := googleapi.CheckResponse(res); err != nil {
  5324  		return nil, gensupport.WrapError(err)
  5325  	}
  5326  	ret := &SasPortalOperation{
  5327  		ServerResponse: googleapi.ServerResponse{
  5328  			Header:         res.Header,
  5329  			HTTPStatusCode: res.StatusCode,
  5330  		},
  5331  	}
  5332  	target := &ret
  5333  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5334  		return nil, err
  5335  	}
  5336  	return ret, nil
  5337  }
  5338  
  5339  type CustomersNodesPatchCall struct {
  5340  	s             *Service
  5341  	name          string
  5342  	sasportalnode *SasPortalNode
  5343  	urlParams_    gensupport.URLParams
  5344  	ctx_          context.Context
  5345  	header_       http.Header
  5346  }
  5347  
  5348  // Patch: Updates an existing node.
  5349  //
  5350  // - name: Output only. Resource name.
  5351  func (r *CustomersNodesService) Patch(name string, sasportalnode *SasPortalNode) *CustomersNodesPatchCall {
  5352  	c := &CustomersNodesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5353  	c.name = name
  5354  	c.sasportalnode = sasportalnode
  5355  	return c
  5356  }
  5357  
  5358  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  5359  func (c *CustomersNodesPatchCall) UpdateMask(updateMask string) *CustomersNodesPatchCall {
  5360  	c.urlParams_.Set("updateMask", updateMask)
  5361  	return c
  5362  }
  5363  
  5364  // Fields allows partial responses to be retrieved. See
  5365  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5366  // details.
  5367  func (c *CustomersNodesPatchCall) Fields(s ...googleapi.Field) *CustomersNodesPatchCall {
  5368  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5369  	return c
  5370  }
  5371  
  5372  // Context sets the context to be used in this call's Do method.
  5373  func (c *CustomersNodesPatchCall) Context(ctx context.Context) *CustomersNodesPatchCall {
  5374  	c.ctx_ = ctx
  5375  	return c
  5376  }
  5377  
  5378  // Header returns a http.Header that can be modified by the caller to add
  5379  // headers to the request.
  5380  func (c *CustomersNodesPatchCall) Header() http.Header {
  5381  	if c.header_ == nil {
  5382  		c.header_ = make(http.Header)
  5383  	}
  5384  	return c.header_
  5385  }
  5386  
  5387  func (c *CustomersNodesPatchCall) doRequest(alt string) (*http.Response, error) {
  5388  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  5389  	var body io.Reader = nil
  5390  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
  5391  	if err != nil {
  5392  		return nil, err
  5393  	}
  5394  	c.urlParams_.Set("alt", alt)
  5395  	c.urlParams_.Set("prettyPrint", "false")
  5396  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  5397  	urls += "?" + c.urlParams_.Encode()
  5398  	req, err := http.NewRequest("PATCH", urls, body)
  5399  	if err != nil {
  5400  		return nil, err
  5401  	}
  5402  	req.Header = reqHeaders
  5403  	googleapi.Expand(req.URL, map[string]string{
  5404  		"name": c.name,
  5405  	})
  5406  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5407  }
  5408  
  5409  // Do executes the "sasportal.customers.nodes.patch" call.
  5410  // Any non-2xx status code is an error. Response headers are in either
  5411  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  5412  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  5413  // whether the returned error was because http.StatusNotModified was returned.
  5414  func (c *CustomersNodesPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  5415  	gensupport.SetOptions(c.urlParams_, opts...)
  5416  	res, err := c.doRequest("json")
  5417  	if res != nil && res.StatusCode == http.StatusNotModified {
  5418  		if res.Body != nil {
  5419  			res.Body.Close()
  5420  		}
  5421  		return nil, gensupport.WrapError(&googleapi.Error{
  5422  			Code:   res.StatusCode,
  5423  			Header: res.Header,
  5424  		})
  5425  	}
  5426  	if err != nil {
  5427  		return nil, err
  5428  	}
  5429  	defer googleapi.CloseBody(res)
  5430  	if err := googleapi.CheckResponse(res); err != nil {
  5431  		return nil, gensupport.WrapError(err)
  5432  	}
  5433  	ret := &SasPortalNode{
  5434  		ServerResponse: googleapi.ServerResponse{
  5435  			Header:         res.Header,
  5436  			HTTPStatusCode: res.StatusCode,
  5437  		},
  5438  	}
  5439  	target := &ret
  5440  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5441  		return nil, err
  5442  	}
  5443  	return ret, nil
  5444  }
  5445  
  5446  type CustomersNodesDeploymentsCreateCall struct {
  5447  	s                   *Service
  5448  	parent              string
  5449  	sasportaldeployment *SasPortalDeployment
  5450  	urlParams_          gensupport.URLParams
  5451  	ctx_                context.Context
  5452  	header_             http.Header
  5453  }
  5454  
  5455  // Create: Creates a new deployment.
  5456  //
  5457  // - parent: The parent resource name where the deployment is to be created.
  5458  func (r *CustomersNodesDeploymentsService) Create(parent string, sasportaldeployment *SasPortalDeployment) *CustomersNodesDeploymentsCreateCall {
  5459  	c := &CustomersNodesDeploymentsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5460  	c.parent = parent
  5461  	c.sasportaldeployment = sasportaldeployment
  5462  	return c
  5463  }
  5464  
  5465  // Fields allows partial responses to be retrieved. See
  5466  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5467  // details.
  5468  func (c *CustomersNodesDeploymentsCreateCall) Fields(s ...googleapi.Field) *CustomersNodesDeploymentsCreateCall {
  5469  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5470  	return c
  5471  }
  5472  
  5473  // Context sets the context to be used in this call's Do method.
  5474  func (c *CustomersNodesDeploymentsCreateCall) Context(ctx context.Context) *CustomersNodesDeploymentsCreateCall {
  5475  	c.ctx_ = ctx
  5476  	return c
  5477  }
  5478  
  5479  // Header returns a http.Header that can be modified by the caller to add
  5480  // headers to the request.
  5481  func (c *CustomersNodesDeploymentsCreateCall) Header() http.Header {
  5482  	if c.header_ == nil {
  5483  		c.header_ = make(http.Header)
  5484  	}
  5485  	return c.header_
  5486  }
  5487  
  5488  func (c *CustomersNodesDeploymentsCreateCall) doRequest(alt string) (*http.Response, error) {
  5489  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  5490  	var body io.Reader = nil
  5491  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldeployment)
  5492  	if err != nil {
  5493  		return nil, err
  5494  	}
  5495  	c.urlParams_.Set("alt", alt)
  5496  	c.urlParams_.Set("prettyPrint", "false")
  5497  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  5498  	urls += "?" + c.urlParams_.Encode()
  5499  	req, err := http.NewRequest("POST", urls, body)
  5500  	if err != nil {
  5501  		return nil, err
  5502  	}
  5503  	req.Header = reqHeaders
  5504  	googleapi.Expand(req.URL, map[string]string{
  5505  		"parent": c.parent,
  5506  	})
  5507  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5508  }
  5509  
  5510  // Do executes the "sasportal.customers.nodes.deployments.create" call.
  5511  // Any non-2xx status code is an error. Response headers are in either
  5512  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  5513  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  5514  // check whether the returned error was because http.StatusNotModified was
  5515  // returned.
  5516  func (c *CustomersNodesDeploymentsCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  5517  	gensupport.SetOptions(c.urlParams_, opts...)
  5518  	res, err := c.doRequest("json")
  5519  	if res != nil && res.StatusCode == http.StatusNotModified {
  5520  		if res.Body != nil {
  5521  			res.Body.Close()
  5522  		}
  5523  		return nil, gensupport.WrapError(&googleapi.Error{
  5524  			Code:   res.StatusCode,
  5525  			Header: res.Header,
  5526  		})
  5527  	}
  5528  	if err != nil {
  5529  		return nil, err
  5530  	}
  5531  	defer googleapi.CloseBody(res)
  5532  	if err := googleapi.CheckResponse(res); err != nil {
  5533  		return nil, gensupport.WrapError(err)
  5534  	}
  5535  	ret := &SasPortalDeployment{
  5536  		ServerResponse: googleapi.ServerResponse{
  5537  			Header:         res.Header,
  5538  			HTTPStatusCode: res.StatusCode,
  5539  		},
  5540  	}
  5541  	target := &ret
  5542  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5543  		return nil, err
  5544  	}
  5545  	return ret, nil
  5546  }
  5547  
  5548  type CustomersNodesDeploymentsListCall struct {
  5549  	s            *Service
  5550  	parent       string
  5551  	urlParams_   gensupport.URLParams
  5552  	ifNoneMatch_ string
  5553  	ctx_         context.Context
  5554  	header_      http.Header
  5555  }
  5556  
  5557  // List: Lists deployments.
  5558  //
  5559  //   - parent: The parent resource name, for example, "nodes/1",
  5560  //     customer/1/nodes/2.
  5561  func (r *CustomersNodesDeploymentsService) List(parent string) *CustomersNodesDeploymentsListCall {
  5562  	c := &CustomersNodesDeploymentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5563  	c.parent = parent
  5564  	return c
  5565  }
  5566  
  5567  // Filter sets the optional parameter "filter": The filter expression. The
  5568  // filter should have the following format: "DIRECT_CHILDREN" or format:
  5569  // "direct_children". The filter is case insensitive. If empty, then no
  5570  // deployments are filtered.
  5571  func (c *CustomersNodesDeploymentsListCall) Filter(filter string) *CustomersNodesDeploymentsListCall {
  5572  	c.urlParams_.Set("filter", filter)
  5573  	return c
  5574  }
  5575  
  5576  // PageSize sets the optional parameter "pageSize": The maximum number of
  5577  // deployments to return in the response.
  5578  func (c *CustomersNodesDeploymentsListCall) PageSize(pageSize int64) *CustomersNodesDeploymentsListCall {
  5579  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  5580  	return c
  5581  }
  5582  
  5583  // PageToken sets the optional parameter "pageToken": A pagination token
  5584  // returned from a previous call to ListDeployments that indicates where this
  5585  // listing should continue from.
  5586  func (c *CustomersNodesDeploymentsListCall) PageToken(pageToken string) *CustomersNodesDeploymentsListCall {
  5587  	c.urlParams_.Set("pageToken", pageToken)
  5588  	return c
  5589  }
  5590  
  5591  // Fields allows partial responses to be retrieved. See
  5592  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5593  // details.
  5594  func (c *CustomersNodesDeploymentsListCall) Fields(s ...googleapi.Field) *CustomersNodesDeploymentsListCall {
  5595  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5596  	return c
  5597  }
  5598  
  5599  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  5600  // object's ETag matches the given value. This is useful for getting updates
  5601  // only after the object has changed since the last request.
  5602  func (c *CustomersNodesDeploymentsListCall) IfNoneMatch(entityTag string) *CustomersNodesDeploymentsListCall {
  5603  	c.ifNoneMatch_ = entityTag
  5604  	return c
  5605  }
  5606  
  5607  // Context sets the context to be used in this call's Do method.
  5608  func (c *CustomersNodesDeploymentsListCall) Context(ctx context.Context) *CustomersNodesDeploymentsListCall {
  5609  	c.ctx_ = ctx
  5610  	return c
  5611  }
  5612  
  5613  // Header returns a http.Header that can be modified by the caller to add
  5614  // headers to the request.
  5615  func (c *CustomersNodesDeploymentsListCall) Header() http.Header {
  5616  	if c.header_ == nil {
  5617  		c.header_ = make(http.Header)
  5618  	}
  5619  	return c.header_
  5620  }
  5621  
  5622  func (c *CustomersNodesDeploymentsListCall) doRequest(alt string) (*http.Response, error) {
  5623  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  5624  	if c.ifNoneMatch_ != "" {
  5625  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  5626  	}
  5627  	var body io.Reader = nil
  5628  	c.urlParams_.Set("alt", alt)
  5629  	c.urlParams_.Set("prettyPrint", "false")
  5630  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  5631  	urls += "?" + c.urlParams_.Encode()
  5632  	req, err := http.NewRequest("GET", urls, body)
  5633  	if err != nil {
  5634  		return nil, err
  5635  	}
  5636  	req.Header = reqHeaders
  5637  	googleapi.Expand(req.URL, map[string]string{
  5638  		"parent": c.parent,
  5639  	})
  5640  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5641  }
  5642  
  5643  // Do executes the "sasportal.customers.nodes.deployments.list" call.
  5644  // Any non-2xx status code is an error. Response headers are in either
  5645  // *SasPortalListDeploymentsResponse.ServerResponse.Header or (if a response
  5646  // was returned at all) in error.(*googleapi.Error).Header. Use
  5647  // googleapi.IsNotModified to check whether the returned error was because
  5648  // http.StatusNotModified was returned.
  5649  func (c *CustomersNodesDeploymentsListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDeploymentsResponse, error) {
  5650  	gensupport.SetOptions(c.urlParams_, opts...)
  5651  	res, err := c.doRequest("json")
  5652  	if res != nil && res.StatusCode == http.StatusNotModified {
  5653  		if res.Body != nil {
  5654  			res.Body.Close()
  5655  		}
  5656  		return nil, gensupport.WrapError(&googleapi.Error{
  5657  			Code:   res.StatusCode,
  5658  			Header: res.Header,
  5659  		})
  5660  	}
  5661  	if err != nil {
  5662  		return nil, err
  5663  	}
  5664  	defer googleapi.CloseBody(res)
  5665  	if err := googleapi.CheckResponse(res); err != nil {
  5666  		return nil, gensupport.WrapError(err)
  5667  	}
  5668  	ret := &SasPortalListDeploymentsResponse{
  5669  		ServerResponse: googleapi.ServerResponse{
  5670  			Header:         res.Header,
  5671  			HTTPStatusCode: res.StatusCode,
  5672  		},
  5673  	}
  5674  	target := &ret
  5675  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5676  		return nil, err
  5677  	}
  5678  	return ret, nil
  5679  }
  5680  
  5681  // Pages invokes f for each page of results.
  5682  // A non-nil error returned from f will halt the iteration.
  5683  // The provided context supersedes any context provided to the Context method.
  5684  func (c *CustomersNodesDeploymentsListCall) Pages(ctx context.Context, f func(*SasPortalListDeploymentsResponse) error) error {
  5685  	c.ctx_ = ctx
  5686  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  5687  	for {
  5688  		x, err := c.Do()
  5689  		if err != nil {
  5690  			return err
  5691  		}
  5692  		if err := f(x); err != nil {
  5693  			return err
  5694  		}
  5695  		if x.NextPageToken == "" {
  5696  			return nil
  5697  		}
  5698  		c.PageToken(x.NextPageToken)
  5699  	}
  5700  }
  5701  
  5702  type CustomersNodesDevicesCreateCall struct {
  5703  	s               *Service
  5704  	parent          string
  5705  	sasportaldevice *SasPortalDevice
  5706  	urlParams_      gensupport.URLParams
  5707  	ctx_            context.Context
  5708  	header_         http.Header
  5709  }
  5710  
  5711  // Create: Creates a device under a node or customer.
  5712  //
  5713  // - parent: The name of the parent resource.
  5714  func (r *CustomersNodesDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *CustomersNodesDevicesCreateCall {
  5715  	c := &CustomersNodesDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5716  	c.parent = parent
  5717  	c.sasportaldevice = sasportaldevice
  5718  	return c
  5719  }
  5720  
  5721  // Fields allows partial responses to be retrieved. See
  5722  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5723  // details.
  5724  func (c *CustomersNodesDevicesCreateCall) Fields(s ...googleapi.Field) *CustomersNodesDevicesCreateCall {
  5725  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5726  	return c
  5727  }
  5728  
  5729  // Context sets the context to be used in this call's Do method.
  5730  func (c *CustomersNodesDevicesCreateCall) Context(ctx context.Context) *CustomersNodesDevicesCreateCall {
  5731  	c.ctx_ = ctx
  5732  	return c
  5733  }
  5734  
  5735  // Header returns a http.Header that can be modified by the caller to add
  5736  // headers to the request.
  5737  func (c *CustomersNodesDevicesCreateCall) Header() http.Header {
  5738  	if c.header_ == nil {
  5739  		c.header_ = make(http.Header)
  5740  	}
  5741  	return c.header_
  5742  }
  5743  
  5744  func (c *CustomersNodesDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
  5745  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  5746  	var body io.Reader = nil
  5747  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  5748  	if err != nil {
  5749  		return nil, err
  5750  	}
  5751  	c.urlParams_.Set("alt", alt)
  5752  	c.urlParams_.Set("prettyPrint", "false")
  5753  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  5754  	urls += "?" + c.urlParams_.Encode()
  5755  	req, err := http.NewRequest("POST", urls, body)
  5756  	if err != nil {
  5757  		return nil, err
  5758  	}
  5759  	req.Header = reqHeaders
  5760  	googleapi.Expand(req.URL, map[string]string{
  5761  		"parent": c.parent,
  5762  	})
  5763  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5764  }
  5765  
  5766  // Do executes the "sasportal.customers.nodes.devices.create" call.
  5767  // Any non-2xx status code is an error. Response headers are in either
  5768  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  5769  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  5770  // check whether the returned error was because http.StatusNotModified was
  5771  // returned.
  5772  func (c *CustomersNodesDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  5773  	gensupport.SetOptions(c.urlParams_, opts...)
  5774  	res, err := c.doRequest("json")
  5775  	if res != nil && res.StatusCode == http.StatusNotModified {
  5776  		if res.Body != nil {
  5777  			res.Body.Close()
  5778  		}
  5779  		return nil, gensupport.WrapError(&googleapi.Error{
  5780  			Code:   res.StatusCode,
  5781  			Header: res.Header,
  5782  		})
  5783  	}
  5784  	if err != nil {
  5785  		return nil, err
  5786  	}
  5787  	defer googleapi.CloseBody(res)
  5788  	if err := googleapi.CheckResponse(res); err != nil {
  5789  		return nil, gensupport.WrapError(err)
  5790  	}
  5791  	ret := &SasPortalDevice{
  5792  		ServerResponse: googleapi.ServerResponse{
  5793  			Header:         res.Header,
  5794  			HTTPStatusCode: res.StatusCode,
  5795  		},
  5796  	}
  5797  	target := &ret
  5798  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5799  		return nil, err
  5800  	}
  5801  	return ret, nil
  5802  }
  5803  
  5804  type CustomersNodesDevicesCreateSignedCall struct {
  5805  	s                                  *Service
  5806  	parent                             string
  5807  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
  5808  	urlParams_                         gensupport.URLParams
  5809  	ctx_                               context.Context
  5810  	header_                            http.Header
  5811  }
  5812  
  5813  // CreateSigned: Creates a signed device under a node or customer.
  5814  //
  5815  // - parent: The name of the parent resource.
  5816  func (r *CustomersNodesDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *CustomersNodesDevicesCreateSignedCall {
  5817  	c := &CustomersNodesDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5818  	c.parent = parent
  5819  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
  5820  	return c
  5821  }
  5822  
  5823  // Fields allows partial responses to be retrieved. See
  5824  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5825  // details.
  5826  func (c *CustomersNodesDevicesCreateSignedCall) Fields(s ...googleapi.Field) *CustomersNodesDevicesCreateSignedCall {
  5827  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5828  	return c
  5829  }
  5830  
  5831  // Context sets the context to be used in this call's Do method.
  5832  func (c *CustomersNodesDevicesCreateSignedCall) Context(ctx context.Context) *CustomersNodesDevicesCreateSignedCall {
  5833  	c.ctx_ = ctx
  5834  	return c
  5835  }
  5836  
  5837  // Header returns a http.Header that can be modified by the caller to add
  5838  // headers to the request.
  5839  func (c *CustomersNodesDevicesCreateSignedCall) Header() http.Header {
  5840  	if c.header_ == nil {
  5841  		c.header_ = make(http.Header)
  5842  	}
  5843  	return c.header_
  5844  }
  5845  
  5846  func (c *CustomersNodesDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
  5847  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  5848  	var body io.Reader = nil
  5849  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
  5850  	if err != nil {
  5851  		return nil, err
  5852  	}
  5853  	c.urlParams_.Set("alt", alt)
  5854  	c.urlParams_.Set("prettyPrint", "false")
  5855  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
  5856  	urls += "?" + c.urlParams_.Encode()
  5857  	req, err := http.NewRequest("POST", urls, body)
  5858  	if err != nil {
  5859  		return nil, err
  5860  	}
  5861  	req.Header = reqHeaders
  5862  	googleapi.Expand(req.URL, map[string]string{
  5863  		"parent": c.parent,
  5864  	})
  5865  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5866  }
  5867  
  5868  // Do executes the "sasportal.customers.nodes.devices.createSigned" call.
  5869  // Any non-2xx status code is an error. Response headers are in either
  5870  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  5871  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  5872  // check whether the returned error was because http.StatusNotModified was
  5873  // returned.
  5874  func (c *CustomersNodesDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  5875  	gensupport.SetOptions(c.urlParams_, opts...)
  5876  	res, err := c.doRequest("json")
  5877  	if res != nil && res.StatusCode == http.StatusNotModified {
  5878  		if res.Body != nil {
  5879  			res.Body.Close()
  5880  		}
  5881  		return nil, gensupport.WrapError(&googleapi.Error{
  5882  			Code:   res.StatusCode,
  5883  			Header: res.Header,
  5884  		})
  5885  	}
  5886  	if err != nil {
  5887  		return nil, err
  5888  	}
  5889  	defer googleapi.CloseBody(res)
  5890  	if err := googleapi.CheckResponse(res); err != nil {
  5891  		return nil, gensupport.WrapError(err)
  5892  	}
  5893  	ret := &SasPortalDevice{
  5894  		ServerResponse: googleapi.ServerResponse{
  5895  			Header:         res.Header,
  5896  			HTTPStatusCode: res.StatusCode,
  5897  		},
  5898  	}
  5899  	target := &ret
  5900  	if err := gensupport.DecodeResponse(target, res); err != nil {
  5901  		return nil, err
  5902  	}
  5903  	return ret, nil
  5904  }
  5905  
  5906  type CustomersNodesDevicesListCall struct {
  5907  	s            *Service
  5908  	parent       string
  5909  	urlParams_   gensupport.URLParams
  5910  	ifNoneMatch_ string
  5911  	ctx_         context.Context
  5912  	header_      http.Header
  5913  }
  5914  
  5915  // List: Lists devices under a node or customer.
  5916  //
  5917  // - parent: The name of the parent resource.
  5918  func (r *CustomersNodesDevicesService) List(parent string) *CustomersNodesDevicesListCall {
  5919  	c := &CustomersNodesDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  5920  	c.parent = parent
  5921  	return c
  5922  }
  5923  
  5924  // Filter sets the optional parameter "filter": The filter expression. The
  5925  // filter should have one of the following formats: "sn=123454" or
  5926  // "display_name=MyDevice". sn corresponds to serial number of the device. The
  5927  // filter is case insensitive.
  5928  func (c *CustomersNodesDevicesListCall) Filter(filter string) *CustomersNodesDevicesListCall {
  5929  	c.urlParams_.Set("filter", filter)
  5930  	return c
  5931  }
  5932  
  5933  // PageSize sets the optional parameter "pageSize": The maximum number of
  5934  // devices to return in the response. If empty or zero, all devices will be
  5935  // listed. Must be in the range [0, 1000].
  5936  func (c *CustomersNodesDevicesListCall) PageSize(pageSize int64) *CustomersNodesDevicesListCall {
  5937  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  5938  	return c
  5939  }
  5940  
  5941  // PageToken sets the optional parameter "pageToken": A pagination token
  5942  // returned from a previous call to ListDevices that indicates where this
  5943  // listing should continue from.
  5944  func (c *CustomersNodesDevicesListCall) PageToken(pageToken string) *CustomersNodesDevicesListCall {
  5945  	c.urlParams_.Set("pageToken", pageToken)
  5946  	return c
  5947  }
  5948  
  5949  // Fields allows partial responses to be retrieved. See
  5950  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  5951  // details.
  5952  func (c *CustomersNodesDevicesListCall) Fields(s ...googleapi.Field) *CustomersNodesDevicesListCall {
  5953  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  5954  	return c
  5955  }
  5956  
  5957  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  5958  // object's ETag matches the given value. This is useful for getting updates
  5959  // only after the object has changed since the last request.
  5960  func (c *CustomersNodesDevicesListCall) IfNoneMatch(entityTag string) *CustomersNodesDevicesListCall {
  5961  	c.ifNoneMatch_ = entityTag
  5962  	return c
  5963  }
  5964  
  5965  // Context sets the context to be used in this call's Do method.
  5966  func (c *CustomersNodesDevicesListCall) Context(ctx context.Context) *CustomersNodesDevicesListCall {
  5967  	c.ctx_ = ctx
  5968  	return c
  5969  }
  5970  
  5971  // Header returns a http.Header that can be modified by the caller to add
  5972  // headers to the request.
  5973  func (c *CustomersNodesDevicesListCall) Header() http.Header {
  5974  	if c.header_ == nil {
  5975  		c.header_ = make(http.Header)
  5976  	}
  5977  	return c.header_
  5978  }
  5979  
  5980  func (c *CustomersNodesDevicesListCall) doRequest(alt string) (*http.Response, error) {
  5981  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  5982  	if c.ifNoneMatch_ != "" {
  5983  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  5984  	}
  5985  	var body io.Reader = nil
  5986  	c.urlParams_.Set("alt", alt)
  5987  	c.urlParams_.Set("prettyPrint", "false")
  5988  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  5989  	urls += "?" + c.urlParams_.Encode()
  5990  	req, err := http.NewRequest("GET", urls, body)
  5991  	if err != nil {
  5992  		return nil, err
  5993  	}
  5994  	req.Header = reqHeaders
  5995  	googleapi.Expand(req.URL, map[string]string{
  5996  		"parent": c.parent,
  5997  	})
  5998  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  5999  }
  6000  
  6001  // Do executes the "sasportal.customers.nodes.devices.list" call.
  6002  // Any non-2xx status code is an error. Response headers are in either
  6003  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
  6004  // returned at all) in error.(*googleapi.Error).Header. Use
  6005  // googleapi.IsNotModified to check whether the returned error was because
  6006  // http.StatusNotModified was returned.
  6007  func (c *CustomersNodesDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
  6008  	gensupport.SetOptions(c.urlParams_, opts...)
  6009  	res, err := c.doRequest("json")
  6010  	if res != nil && res.StatusCode == http.StatusNotModified {
  6011  		if res.Body != nil {
  6012  			res.Body.Close()
  6013  		}
  6014  		return nil, gensupport.WrapError(&googleapi.Error{
  6015  			Code:   res.StatusCode,
  6016  			Header: res.Header,
  6017  		})
  6018  	}
  6019  	if err != nil {
  6020  		return nil, err
  6021  	}
  6022  	defer googleapi.CloseBody(res)
  6023  	if err := googleapi.CheckResponse(res); err != nil {
  6024  		return nil, gensupport.WrapError(err)
  6025  	}
  6026  	ret := &SasPortalListDevicesResponse{
  6027  		ServerResponse: googleapi.ServerResponse{
  6028  			Header:         res.Header,
  6029  			HTTPStatusCode: res.StatusCode,
  6030  		},
  6031  	}
  6032  	target := &ret
  6033  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6034  		return nil, err
  6035  	}
  6036  	return ret, nil
  6037  }
  6038  
  6039  // Pages invokes f for each page of results.
  6040  // A non-nil error returned from f will halt the iteration.
  6041  // The provided context supersedes any context provided to the Context method.
  6042  func (c *CustomersNodesDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
  6043  	c.ctx_ = ctx
  6044  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  6045  	for {
  6046  		x, err := c.Do()
  6047  		if err != nil {
  6048  			return err
  6049  		}
  6050  		if err := f(x); err != nil {
  6051  			return err
  6052  		}
  6053  		if x.NextPageToken == "" {
  6054  			return nil
  6055  		}
  6056  		c.PageToken(x.NextPageToken)
  6057  	}
  6058  }
  6059  
  6060  type CustomersNodesNodesCreateCall struct {
  6061  	s             *Service
  6062  	parent        string
  6063  	sasportalnode *SasPortalNode
  6064  	urlParams_    gensupport.URLParams
  6065  	ctx_          context.Context
  6066  	header_       http.Header
  6067  }
  6068  
  6069  // Create: Creates a new node.
  6070  //
  6071  // - parent: The parent resource name where the node is to be created.
  6072  func (r *CustomersNodesNodesService) Create(parent string, sasportalnode *SasPortalNode) *CustomersNodesNodesCreateCall {
  6073  	c := &CustomersNodesNodesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6074  	c.parent = parent
  6075  	c.sasportalnode = sasportalnode
  6076  	return c
  6077  }
  6078  
  6079  // Fields allows partial responses to be retrieved. See
  6080  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6081  // details.
  6082  func (c *CustomersNodesNodesCreateCall) Fields(s ...googleapi.Field) *CustomersNodesNodesCreateCall {
  6083  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6084  	return c
  6085  }
  6086  
  6087  // Context sets the context to be used in this call's Do method.
  6088  func (c *CustomersNodesNodesCreateCall) Context(ctx context.Context) *CustomersNodesNodesCreateCall {
  6089  	c.ctx_ = ctx
  6090  	return c
  6091  }
  6092  
  6093  // Header returns a http.Header that can be modified by the caller to add
  6094  // headers to the request.
  6095  func (c *CustomersNodesNodesCreateCall) Header() http.Header {
  6096  	if c.header_ == nil {
  6097  		c.header_ = make(http.Header)
  6098  	}
  6099  	return c.header_
  6100  }
  6101  
  6102  func (c *CustomersNodesNodesCreateCall) doRequest(alt string) (*http.Response, error) {
  6103  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  6104  	var body io.Reader = nil
  6105  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
  6106  	if err != nil {
  6107  		return nil, err
  6108  	}
  6109  	c.urlParams_.Set("alt", alt)
  6110  	c.urlParams_.Set("prettyPrint", "false")
  6111  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  6112  	urls += "?" + c.urlParams_.Encode()
  6113  	req, err := http.NewRequest("POST", urls, body)
  6114  	if err != nil {
  6115  		return nil, err
  6116  	}
  6117  	req.Header = reqHeaders
  6118  	googleapi.Expand(req.URL, map[string]string{
  6119  		"parent": c.parent,
  6120  	})
  6121  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6122  }
  6123  
  6124  // Do executes the "sasportal.customers.nodes.nodes.create" call.
  6125  // Any non-2xx status code is an error. Response headers are in either
  6126  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  6127  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  6128  // whether the returned error was because http.StatusNotModified was returned.
  6129  func (c *CustomersNodesNodesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  6130  	gensupport.SetOptions(c.urlParams_, opts...)
  6131  	res, err := c.doRequest("json")
  6132  	if res != nil && res.StatusCode == http.StatusNotModified {
  6133  		if res.Body != nil {
  6134  			res.Body.Close()
  6135  		}
  6136  		return nil, gensupport.WrapError(&googleapi.Error{
  6137  			Code:   res.StatusCode,
  6138  			Header: res.Header,
  6139  		})
  6140  	}
  6141  	if err != nil {
  6142  		return nil, err
  6143  	}
  6144  	defer googleapi.CloseBody(res)
  6145  	if err := googleapi.CheckResponse(res); err != nil {
  6146  		return nil, gensupport.WrapError(err)
  6147  	}
  6148  	ret := &SasPortalNode{
  6149  		ServerResponse: googleapi.ServerResponse{
  6150  			Header:         res.Header,
  6151  			HTTPStatusCode: res.StatusCode,
  6152  		},
  6153  	}
  6154  	target := &ret
  6155  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6156  		return nil, err
  6157  	}
  6158  	return ret, nil
  6159  }
  6160  
  6161  type CustomersNodesNodesListCall struct {
  6162  	s            *Service
  6163  	parent       string
  6164  	urlParams_   gensupport.URLParams
  6165  	ifNoneMatch_ string
  6166  	ctx_         context.Context
  6167  	header_      http.Header
  6168  }
  6169  
  6170  // List: Lists nodes.
  6171  //
  6172  // - parent: The parent resource name, for example, "nodes/1".
  6173  func (r *CustomersNodesNodesService) List(parent string) *CustomersNodesNodesListCall {
  6174  	c := &CustomersNodesNodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6175  	c.parent = parent
  6176  	return c
  6177  }
  6178  
  6179  // Filter sets the optional parameter "filter": The filter expression. The
  6180  // filter should have the following format: "DIRECT_CHILDREN" or format:
  6181  // "direct_children". The filter is case insensitive. If empty, then no nodes
  6182  // are filtered.
  6183  func (c *CustomersNodesNodesListCall) Filter(filter string) *CustomersNodesNodesListCall {
  6184  	c.urlParams_.Set("filter", filter)
  6185  	return c
  6186  }
  6187  
  6188  // PageSize sets the optional parameter "pageSize": The maximum number of nodes
  6189  // to return in the response.
  6190  func (c *CustomersNodesNodesListCall) PageSize(pageSize int64) *CustomersNodesNodesListCall {
  6191  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  6192  	return c
  6193  }
  6194  
  6195  // PageToken sets the optional parameter "pageToken": A pagination token
  6196  // returned from a previous call to ListNodes that indicates where this listing
  6197  // should continue from.
  6198  func (c *CustomersNodesNodesListCall) PageToken(pageToken string) *CustomersNodesNodesListCall {
  6199  	c.urlParams_.Set("pageToken", pageToken)
  6200  	return c
  6201  }
  6202  
  6203  // Fields allows partial responses to be retrieved. See
  6204  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6205  // details.
  6206  func (c *CustomersNodesNodesListCall) Fields(s ...googleapi.Field) *CustomersNodesNodesListCall {
  6207  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6208  	return c
  6209  }
  6210  
  6211  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  6212  // object's ETag matches the given value. This is useful for getting updates
  6213  // only after the object has changed since the last request.
  6214  func (c *CustomersNodesNodesListCall) IfNoneMatch(entityTag string) *CustomersNodesNodesListCall {
  6215  	c.ifNoneMatch_ = entityTag
  6216  	return c
  6217  }
  6218  
  6219  // Context sets the context to be used in this call's Do method.
  6220  func (c *CustomersNodesNodesListCall) Context(ctx context.Context) *CustomersNodesNodesListCall {
  6221  	c.ctx_ = ctx
  6222  	return c
  6223  }
  6224  
  6225  // Header returns a http.Header that can be modified by the caller to add
  6226  // headers to the request.
  6227  func (c *CustomersNodesNodesListCall) Header() http.Header {
  6228  	if c.header_ == nil {
  6229  		c.header_ = make(http.Header)
  6230  	}
  6231  	return c.header_
  6232  }
  6233  
  6234  func (c *CustomersNodesNodesListCall) doRequest(alt string) (*http.Response, error) {
  6235  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  6236  	if c.ifNoneMatch_ != "" {
  6237  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  6238  	}
  6239  	var body io.Reader = nil
  6240  	c.urlParams_.Set("alt", alt)
  6241  	c.urlParams_.Set("prettyPrint", "false")
  6242  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  6243  	urls += "?" + c.urlParams_.Encode()
  6244  	req, err := http.NewRequest("GET", urls, body)
  6245  	if err != nil {
  6246  		return nil, err
  6247  	}
  6248  	req.Header = reqHeaders
  6249  	googleapi.Expand(req.URL, map[string]string{
  6250  		"parent": c.parent,
  6251  	})
  6252  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6253  }
  6254  
  6255  // Do executes the "sasportal.customers.nodes.nodes.list" call.
  6256  // Any non-2xx status code is an error. Response headers are in either
  6257  // *SasPortalListNodesResponse.ServerResponse.Header or (if a response was
  6258  // returned at all) in error.(*googleapi.Error).Header. Use
  6259  // googleapi.IsNotModified to check whether the returned error was because
  6260  // http.StatusNotModified was returned.
  6261  func (c *CustomersNodesNodesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListNodesResponse, error) {
  6262  	gensupport.SetOptions(c.urlParams_, opts...)
  6263  	res, err := c.doRequest("json")
  6264  	if res != nil && res.StatusCode == http.StatusNotModified {
  6265  		if res.Body != nil {
  6266  			res.Body.Close()
  6267  		}
  6268  		return nil, gensupport.WrapError(&googleapi.Error{
  6269  			Code:   res.StatusCode,
  6270  			Header: res.Header,
  6271  		})
  6272  	}
  6273  	if err != nil {
  6274  		return nil, err
  6275  	}
  6276  	defer googleapi.CloseBody(res)
  6277  	if err := googleapi.CheckResponse(res); err != nil {
  6278  		return nil, gensupport.WrapError(err)
  6279  	}
  6280  	ret := &SasPortalListNodesResponse{
  6281  		ServerResponse: googleapi.ServerResponse{
  6282  			Header:         res.Header,
  6283  			HTTPStatusCode: res.StatusCode,
  6284  		},
  6285  	}
  6286  	target := &ret
  6287  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6288  		return nil, err
  6289  	}
  6290  	return ret, nil
  6291  }
  6292  
  6293  // Pages invokes f for each page of results.
  6294  // A non-nil error returned from f will halt the iteration.
  6295  // The provided context supersedes any context provided to the Context method.
  6296  func (c *CustomersNodesNodesListCall) Pages(ctx context.Context, f func(*SasPortalListNodesResponse) error) error {
  6297  	c.ctx_ = ctx
  6298  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  6299  	for {
  6300  		x, err := c.Do()
  6301  		if err != nil {
  6302  			return err
  6303  		}
  6304  		if err := f(x); err != nil {
  6305  			return err
  6306  		}
  6307  		if x.NextPageToken == "" {
  6308  			return nil
  6309  		}
  6310  		c.PageToken(x.NextPageToken)
  6311  	}
  6312  }
  6313  
  6314  type DeploymentsGetCall struct {
  6315  	s            *Service
  6316  	name         string
  6317  	urlParams_   gensupport.URLParams
  6318  	ifNoneMatch_ string
  6319  	ctx_         context.Context
  6320  	header_      http.Header
  6321  }
  6322  
  6323  // Get: Returns a requested deployment.
  6324  //
  6325  // - name: The name of the deployment.
  6326  func (r *DeploymentsService) Get(name string) *DeploymentsGetCall {
  6327  	c := &DeploymentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6328  	c.name = name
  6329  	return c
  6330  }
  6331  
  6332  // Fields allows partial responses to be retrieved. See
  6333  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6334  // details.
  6335  func (c *DeploymentsGetCall) Fields(s ...googleapi.Field) *DeploymentsGetCall {
  6336  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6337  	return c
  6338  }
  6339  
  6340  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  6341  // object's ETag matches the given value. This is useful for getting updates
  6342  // only after the object has changed since the last request.
  6343  func (c *DeploymentsGetCall) IfNoneMatch(entityTag string) *DeploymentsGetCall {
  6344  	c.ifNoneMatch_ = entityTag
  6345  	return c
  6346  }
  6347  
  6348  // Context sets the context to be used in this call's Do method.
  6349  func (c *DeploymentsGetCall) Context(ctx context.Context) *DeploymentsGetCall {
  6350  	c.ctx_ = ctx
  6351  	return c
  6352  }
  6353  
  6354  // Header returns a http.Header that can be modified by the caller to add
  6355  // headers to the request.
  6356  func (c *DeploymentsGetCall) Header() http.Header {
  6357  	if c.header_ == nil {
  6358  		c.header_ = make(http.Header)
  6359  	}
  6360  	return c.header_
  6361  }
  6362  
  6363  func (c *DeploymentsGetCall) doRequest(alt string) (*http.Response, error) {
  6364  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  6365  	if c.ifNoneMatch_ != "" {
  6366  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  6367  	}
  6368  	var body io.Reader = nil
  6369  	c.urlParams_.Set("alt", alt)
  6370  	c.urlParams_.Set("prettyPrint", "false")
  6371  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  6372  	urls += "?" + c.urlParams_.Encode()
  6373  	req, err := http.NewRequest("GET", urls, body)
  6374  	if err != nil {
  6375  		return nil, err
  6376  	}
  6377  	req.Header = reqHeaders
  6378  	googleapi.Expand(req.URL, map[string]string{
  6379  		"name": c.name,
  6380  	})
  6381  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6382  }
  6383  
  6384  // Do executes the "sasportal.deployments.get" call.
  6385  // Any non-2xx status code is an error. Response headers are in either
  6386  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  6387  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  6388  // check whether the returned error was because http.StatusNotModified was
  6389  // returned.
  6390  func (c *DeploymentsGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  6391  	gensupport.SetOptions(c.urlParams_, opts...)
  6392  	res, err := c.doRequest("json")
  6393  	if res != nil && res.StatusCode == http.StatusNotModified {
  6394  		if res.Body != nil {
  6395  			res.Body.Close()
  6396  		}
  6397  		return nil, gensupport.WrapError(&googleapi.Error{
  6398  			Code:   res.StatusCode,
  6399  			Header: res.Header,
  6400  		})
  6401  	}
  6402  	if err != nil {
  6403  		return nil, err
  6404  	}
  6405  	defer googleapi.CloseBody(res)
  6406  	if err := googleapi.CheckResponse(res); err != nil {
  6407  		return nil, gensupport.WrapError(err)
  6408  	}
  6409  	ret := &SasPortalDeployment{
  6410  		ServerResponse: googleapi.ServerResponse{
  6411  			Header:         res.Header,
  6412  			HTTPStatusCode: res.StatusCode,
  6413  		},
  6414  	}
  6415  	target := &ret
  6416  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6417  		return nil, err
  6418  	}
  6419  	return ret, nil
  6420  }
  6421  
  6422  type DeploymentsDevicesDeleteCall struct {
  6423  	s          *Service
  6424  	name       string
  6425  	urlParams_ gensupport.URLParams
  6426  	ctx_       context.Context
  6427  	header_    http.Header
  6428  }
  6429  
  6430  // Delete: Deletes a device.
  6431  //
  6432  // - name: The name of the device.
  6433  func (r *DeploymentsDevicesService) Delete(name string) *DeploymentsDevicesDeleteCall {
  6434  	c := &DeploymentsDevicesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6435  	c.name = name
  6436  	return c
  6437  }
  6438  
  6439  // Fields allows partial responses to be retrieved. See
  6440  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6441  // details.
  6442  func (c *DeploymentsDevicesDeleteCall) Fields(s ...googleapi.Field) *DeploymentsDevicesDeleteCall {
  6443  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6444  	return c
  6445  }
  6446  
  6447  // Context sets the context to be used in this call's Do method.
  6448  func (c *DeploymentsDevicesDeleteCall) Context(ctx context.Context) *DeploymentsDevicesDeleteCall {
  6449  	c.ctx_ = ctx
  6450  	return c
  6451  }
  6452  
  6453  // Header returns a http.Header that can be modified by the caller to add
  6454  // headers to the request.
  6455  func (c *DeploymentsDevicesDeleteCall) Header() http.Header {
  6456  	if c.header_ == nil {
  6457  		c.header_ = make(http.Header)
  6458  	}
  6459  	return c.header_
  6460  }
  6461  
  6462  func (c *DeploymentsDevicesDeleteCall) doRequest(alt string) (*http.Response, error) {
  6463  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  6464  	var body io.Reader = nil
  6465  	c.urlParams_.Set("alt", alt)
  6466  	c.urlParams_.Set("prettyPrint", "false")
  6467  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  6468  	urls += "?" + c.urlParams_.Encode()
  6469  	req, err := http.NewRequest("DELETE", urls, body)
  6470  	if err != nil {
  6471  		return nil, err
  6472  	}
  6473  	req.Header = reqHeaders
  6474  	googleapi.Expand(req.URL, map[string]string{
  6475  		"name": c.name,
  6476  	})
  6477  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6478  }
  6479  
  6480  // Do executes the "sasportal.deployments.devices.delete" call.
  6481  // Any non-2xx status code is an error. Response headers are in either
  6482  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  6483  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  6484  // whether the returned error was because http.StatusNotModified was returned.
  6485  func (c *DeploymentsDevicesDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  6486  	gensupport.SetOptions(c.urlParams_, opts...)
  6487  	res, err := c.doRequest("json")
  6488  	if res != nil && res.StatusCode == http.StatusNotModified {
  6489  		if res.Body != nil {
  6490  			res.Body.Close()
  6491  		}
  6492  		return nil, gensupport.WrapError(&googleapi.Error{
  6493  			Code:   res.StatusCode,
  6494  			Header: res.Header,
  6495  		})
  6496  	}
  6497  	if err != nil {
  6498  		return nil, err
  6499  	}
  6500  	defer googleapi.CloseBody(res)
  6501  	if err := googleapi.CheckResponse(res); err != nil {
  6502  		return nil, gensupport.WrapError(err)
  6503  	}
  6504  	ret := &SasPortalEmpty{
  6505  		ServerResponse: googleapi.ServerResponse{
  6506  			Header:         res.Header,
  6507  			HTTPStatusCode: res.StatusCode,
  6508  		},
  6509  	}
  6510  	target := &ret
  6511  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6512  		return nil, err
  6513  	}
  6514  	return ret, nil
  6515  }
  6516  
  6517  type DeploymentsDevicesGetCall struct {
  6518  	s            *Service
  6519  	name         string
  6520  	urlParams_   gensupport.URLParams
  6521  	ifNoneMatch_ string
  6522  	ctx_         context.Context
  6523  	header_      http.Header
  6524  }
  6525  
  6526  // Get: Gets details about a device.
  6527  //
  6528  // - name: The name of the device.
  6529  func (r *DeploymentsDevicesService) Get(name string) *DeploymentsDevicesGetCall {
  6530  	c := &DeploymentsDevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6531  	c.name = name
  6532  	return c
  6533  }
  6534  
  6535  // Fields allows partial responses to be retrieved. See
  6536  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6537  // details.
  6538  func (c *DeploymentsDevicesGetCall) Fields(s ...googleapi.Field) *DeploymentsDevicesGetCall {
  6539  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6540  	return c
  6541  }
  6542  
  6543  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  6544  // object's ETag matches the given value. This is useful for getting updates
  6545  // only after the object has changed since the last request.
  6546  func (c *DeploymentsDevicesGetCall) IfNoneMatch(entityTag string) *DeploymentsDevicesGetCall {
  6547  	c.ifNoneMatch_ = entityTag
  6548  	return c
  6549  }
  6550  
  6551  // Context sets the context to be used in this call's Do method.
  6552  func (c *DeploymentsDevicesGetCall) Context(ctx context.Context) *DeploymentsDevicesGetCall {
  6553  	c.ctx_ = ctx
  6554  	return c
  6555  }
  6556  
  6557  // Header returns a http.Header that can be modified by the caller to add
  6558  // headers to the request.
  6559  func (c *DeploymentsDevicesGetCall) Header() http.Header {
  6560  	if c.header_ == nil {
  6561  		c.header_ = make(http.Header)
  6562  	}
  6563  	return c.header_
  6564  }
  6565  
  6566  func (c *DeploymentsDevicesGetCall) doRequest(alt string) (*http.Response, error) {
  6567  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  6568  	if c.ifNoneMatch_ != "" {
  6569  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  6570  	}
  6571  	var body io.Reader = nil
  6572  	c.urlParams_.Set("alt", alt)
  6573  	c.urlParams_.Set("prettyPrint", "false")
  6574  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  6575  	urls += "?" + c.urlParams_.Encode()
  6576  	req, err := http.NewRequest("GET", urls, body)
  6577  	if err != nil {
  6578  		return nil, err
  6579  	}
  6580  	req.Header = reqHeaders
  6581  	googleapi.Expand(req.URL, map[string]string{
  6582  		"name": c.name,
  6583  	})
  6584  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6585  }
  6586  
  6587  // Do executes the "sasportal.deployments.devices.get" call.
  6588  // Any non-2xx status code is an error. Response headers are in either
  6589  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  6590  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  6591  // check whether the returned error was because http.StatusNotModified was
  6592  // returned.
  6593  func (c *DeploymentsDevicesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  6594  	gensupport.SetOptions(c.urlParams_, opts...)
  6595  	res, err := c.doRequest("json")
  6596  	if res != nil && res.StatusCode == http.StatusNotModified {
  6597  		if res.Body != nil {
  6598  			res.Body.Close()
  6599  		}
  6600  		return nil, gensupport.WrapError(&googleapi.Error{
  6601  			Code:   res.StatusCode,
  6602  			Header: res.Header,
  6603  		})
  6604  	}
  6605  	if err != nil {
  6606  		return nil, err
  6607  	}
  6608  	defer googleapi.CloseBody(res)
  6609  	if err := googleapi.CheckResponse(res); err != nil {
  6610  		return nil, gensupport.WrapError(err)
  6611  	}
  6612  	ret := &SasPortalDevice{
  6613  		ServerResponse: googleapi.ServerResponse{
  6614  			Header:         res.Header,
  6615  			HTTPStatusCode: res.StatusCode,
  6616  		},
  6617  	}
  6618  	target := &ret
  6619  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6620  		return nil, err
  6621  	}
  6622  	return ret, nil
  6623  }
  6624  
  6625  type DeploymentsDevicesMoveCall struct {
  6626  	s                          *Service
  6627  	name                       string
  6628  	sasportalmovedevicerequest *SasPortalMoveDeviceRequest
  6629  	urlParams_                 gensupport.URLParams
  6630  	ctx_                       context.Context
  6631  	header_                    http.Header
  6632  }
  6633  
  6634  // Move: Moves a device under another node or customer.
  6635  //
  6636  // - name: The name of the device to move.
  6637  func (r *DeploymentsDevicesService) Move(name string, sasportalmovedevicerequest *SasPortalMoveDeviceRequest) *DeploymentsDevicesMoveCall {
  6638  	c := &DeploymentsDevicesMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6639  	c.name = name
  6640  	c.sasportalmovedevicerequest = sasportalmovedevicerequest
  6641  	return c
  6642  }
  6643  
  6644  // Fields allows partial responses to be retrieved. See
  6645  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6646  // details.
  6647  func (c *DeploymentsDevicesMoveCall) Fields(s ...googleapi.Field) *DeploymentsDevicesMoveCall {
  6648  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6649  	return c
  6650  }
  6651  
  6652  // Context sets the context to be used in this call's Do method.
  6653  func (c *DeploymentsDevicesMoveCall) Context(ctx context.Context) *DeploymentsDevicesMoveCall {
  6654  	c.ctx_ = ctx
  6655  	return c
  6656  }
  6657  
  6658  // Header returns a http.Header that can be modified by the caller to add
  6659  // headers to the request.
  6660  func (c *DeploymentsDevicesMoveCall) Header() http.Header {
  6661  	if c.header_ == nil {
  6662  		c.header_ = make(http.Header)
  6663  	}
  6664  	return c.header_
  6665  }
  6666  
  6667  func (c *DeploymentsDevicesMoveCall) doRequest(alt string) (*http.Response, error) {
  6668  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  6669  	var body io.Reader = nil
  6670  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovedevicerequest)
  6671  	if err != nil {
  6672  		return nil, err
  6673  	}
  6674  	c.urlParams_.Set("alt", alt)
  6675  	c.urlParams_.Set("prettyPrint", "false")
  6676  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  6677  	urls += "?" + c.urlParams_.Encode()
  6678  	req, err := http.NewRequest("POST", urls, body)
  6679  	if err != nil {
  6680  		return nil, err
  6681  	}
  6682  	req.Header = reqHeaders
  6683  	googleapi.Expand(req.URL, map[string]string{
  6684  		"name": c.name,
  6685  	})
  6686  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6687  }
  6688  
  6689  // Do executes the "sasportal.deployments.devices.move" call.
  6690  // Any non-2xx status code is an error. Response headers are in either
  6691  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  6692  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  6693  // check whether the returned error was because http.StatusNotModified was
  6694  // returned.
  6695  func (c *DeploymentsDevicesMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  6696  	gensupport.SetOptions(c.urlParams_, opts...)
  6697  	res, err := c.doRequest("json")
  6698  	if res != nil && res.StatusCode == http.StatusNotModified {
  6699  		if res.Body != nil {
  6700  			res.Body.Close()
  6701  		}
  6702  		return nil, gensupport.WrapError(&googleapi.Error{
  6703  			Code:   res.StatusCode,
  6704  			Header: res.Header,
  6705  		})
  6706  	}
  6707  	if err != nil {
  6708  		return nil, err
  6709  	}
  6710  	defer googleapi.CloseBody(res)
  6711  	if err := googleapi.CheckResponse(res); err != nil {
  6712  		return nil, gensupport.WrapError(err)
  6713  	}
  6714  	ret := &SasPortalOperation{
  6715  		ServerResponse: googleapi.ServerResponse{
  6716  			Header:         res.Header,
  6717  			HTTPStatusCode: res.StatusCode,
  6718  		},
  6719  	}
  6720  	target := &ret
  6721  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6722  		return nil, err
  6723  	}
  6724  	return ret, nil
  6725  }
  6726  
  6727  type DeploymentsDevicesPatchCall struct {
  6728  	s               *Service
  6729  	name            string
  6730  	sasportaldevice *SasPortalDevice
  6731  	urlParams_      gensupport.URLParams
  6732  	ctx_            context.Context
  6733  	header_         http.Header
  6734  }
  6735  
  6736  // Patch: Updates a device.
  6737  //
  6738  // - name: Output only. The resource path name.
  6739  func (r *DeploymentsDevicesService) Patch(name string, sasportaldevice *SasPortalDevice) *DeploymentsDevicesPatchCall {
  6740  	c := &DeploymentsDevicesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6741  	c.name = name
  6742  	c.sasportaldevice = sasportaldevice
  6743  	return c
  6744  }
  6745  
  6746  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  6747  func (c *DeploymentsDevicesPatchCall) UpdateMask(updateMask string) *DeploymentsDevicesPatchCall {
  6748  	c.urlParams_.Set("updateMask", updateMask)
  6749  	return c
  6750  }
  6751  
  6752  // Fields allows partial responses to be retrieved. See
  6753  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6754  // details.
  6755  func (c *DeploymentsDevicesPatchCall) Fields(s ...googleapi.Field) *DeploymentsDevicesPatchCall {
  6756  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6757  	return c
  6758  }
  6759  
  6760  // Context sets the context to be used in this call's Do method.
  6761  func (c *DeploymentsDevicesPatchCall) Context(ctx context.Context) *DeploymentsDevicesPatchCall {
  6762  	c.ctx_ = ctx
  6763  	return c
  6764  }
  6765  
  6766  // Header returns a http.Header that can be modified by the caller to add
  6767  // headers to the request.
  6768  func (c *DeploymentsDevicesPatchCall) Header() http.Header {
  6769  	if c.header_ == nil {
  6770  		c.header_ = make(http.Header)
  6771  	}
  6772  	return c.header_
  6773  }
  6774  
  6775  func (c *DeploymentsDevicesPatchCall) doRequest(alt string) (*http.Response, error) {
  6776  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  6777  	var body io.Reader = nil
  6778  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  6779  	if err != nil {
  6780  		return nil, err
  6781  	}
  6782  	c.urlParams_.Set("alt", alt)
  6783  	c.urlParams_.Set("prettyPrint", "false")
  6784  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  6785  	urls += "?" + c.urlParams_.Encode()
  6786  	req, err := http.NewRequest("PATCH", urls, body)
  6787  	if err != nil {
  6788  		return nil, err
  6789  	}
  6790  	req.Header = reqHeaders
  6791  	googleapi.Expand(req.URL, map[string]string{
  6792  		"name": c.name,
  6793  	})
  6794  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6795  }
  6796  
  6797  // Do executes the "sasportal.deployments.devices.patch" call.
  6798  // Any non-2xx status code is an error. Response headers are in either
  6799  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  6800  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  6801  // check whether the returned error was because http.StatusNotModified was
  6802  // returned.
  6803  func (c *DeploymentsDevicesPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  6804  	gensupport.SetOptions(c.urlParams_, opts...)
  6805  	res, err := c.doRequest("json")
  6806  	if res != nil && res.StatusCode == http.StatusNotModified {
  6807  		if res.Body != nil {
  6808  			res.Body.Close()
  6809  		}
  6810  		return nil, gensupport.WrapError(&googleapi.Error{
  6811  			Code:   res.StatusCode,
  6812  			Header: res.Header,
  6813  		})
  6814  	}
  6815  	if err != nil {
  6816  		return nil, err
  6817  	}
  6818  	defer googleapi.CloseBody(res)
  6819  	if err := googleapi.CheckResponse(res); err != nil {
  6820  		return nil, gensupport.WrapError(err)
  6821  	}
  6822  	ret := &SasPortalDevice{
  6823  		ServerResponse: googleapi.ServerResponse{
  6824  			Header:         res.Header,
  6825  			HTTPStatusCode: res.StatusCode,
  6826  		},
  6827  	}
  6828  	target := &ret
  6829  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6830  		return nil, err
  6831  	}
  6832  	return ret, nil
  6833  }
  6834  
  6835  type DeploymentsDevicesSignDeviceCall struct {
  6836  	s                          *Service
  6837  	name                       string
  6838  	sasportalsigndevicerequest *SasPortalSignDeviceRequest
  6839  	urlParams_                 gensupport.URLParams
  6840  	ctx_                       context.Context
  6841  	header_                    http.Header
  6842  }
  6843  
  6844  // SignDevice: Signs a device.
  6845  //
  6846  // - name: Output only. The resource path name.
  6847  func (r *DeploymentsDevicesService) SignDevice(name string, sasportalsigndevicerequest *SasPortalSignDeviceRequest) *DeploymentsDevicesSignDeviceCall {
  6848  	c := &DeploymentsDevicesSignDeviceCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6849  	c.name = name
  6850  	c.sasportalsigndevicerequest = sasportalsigndevicerequest
  6851  	return c
  6852  }
  6853  
  6854  // Fields allows partial responses to be retrieved. See
  6855  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6856  // details.
  6857  func (c *DeploymentsDevicesSignDeviceCall) Fields(s ...googleapi.Field) *DeploymentsDevicesSignDeviceCall {
  6858  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6859  	return c
  6860  }
  6861  
  6862  // Context sets the context to be used in this call's Do method.
  6863  func (c *DeploymentsDevicesSignDeviceCall) Context(ctx context.Context) *DeploymentsDevicesSignDeviceCall {
  6864  	c.ctx_ = ctx
  6865  	return c
  6866  }
  6867  
  6868  // Header returns a http.Header that can be modified by the caller to add
  6869  // headers to the request.
  6870  func (c *DeploymentsDevicesSignDeviceCall) Header() http.Header {
  6871  	if c.header_ == nil {
  6872  		c.header_ = make(http.Header)
  6873  	}
  6874  	return c.header_
  6875  }
  6876  
  6877  func (c *DeploymentsDevicesSignDeviceCall) doRequest(alt string) (*http.Response, error) {
  6878  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  6879  	var body io.Reader = nil
  6880  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalsigndevicerequest)
  6881  	if err != nil {
  6882  		return nil, err
  6883  	}
  6884  	c.urlParams_.Set("alt", alt)
  6885  	c.urlParams_.Set("prettyPrint", "false")
  6886  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:signDevice")
  6887  	urls += "?" + c.urlParams_.Encode()
  6888  	req, err := http.NewRequest("POST", urls, body)
  6889  	if err != nil {
  6890  		return nil, err
  6891  	}
  6892  	req.Header = reqHeaders
  6893  	googleapi.Expand(req.URL, map[string]string{
  6894  		"name": c.name,
  6895  	})
  6896  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6897  }
  6898  
  6899  // Do executes the "sasportal.deployments.devices.signDevice" call.
  6900  // Any non-2xx status code is an error. Response headers are in either
  6901  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  6902  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  6903  // whether the returned error was because http.StatusNotModified was returned.
  6904  func (c *DeploymentsDevicesSignDeviceCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  6905  	gensupport.SetOptions(c.urlParams_, opts...)
  6906  	res, err := c.doRequest("json")
  6907  	if res != nil && res.StatusCode == http.StatusNotModified {
  6908  		if res.Body != nil {
  6909  			res.Body.Close()
  6910  		}
  6911  		return nil, gensupport.WrapError(&googleapi.Error{
  6912  			Code:   res.StatusCode,
  6913  			Header: res.Header,
  6914  		})
  6915  	}
  6916  	if err != nil {
  6917  		return nil, err
  6918  	}
  6919  	defer googleapi.CloseBody(res)
  6920  	if err := googleapi.CheckResponse(res); err != nil {
  6921  		return nil, gensupport.WrapError(err)
  6922  	}
  6923  	ret := &SasPortalEmpty{
  6924  		ServerResponse: googleapi.ServerResponse{
  6925  			Header:         res.Header,
  6926  			HTTPStatusCode: res.StatusCode,
  6927  		},
  6928  	}
  6929  	target := &ret
  6930  	if err := gensupport.DecodeResponse(target, res); err != nil {
  6931  		return nil, err
  6932  	}
  6933  	return ret, nil
  6934  }
  6935  
  6936  type DeploymentsDevicesUpdateSignedCall struct {
  6937  	s                                  *Service
  6938  	name                               string
  6939  	sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest
  6940  	urlParams_                         gensupport.URLParams
  6941  	ctx_                               context.Context
  6942  	header_                            http.Header
  6943  }
  6944  
  6945  // UpdateSigned: Updates a signed device.
  6946  //
  6947  // - name: The name of the device to update.
  6948  func (r *DeploymentsDevicesService) UpdateSigned(name string, sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest) *DeploymentsDevicesUpdateSignedCall {
  6949  	c := &DeploymentsDevicesUpdateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  6950  	c.name = name
  6951  	c.sasportalupdatesigneddevicerequest = sasportalupdatesigneddevicerequest
  6952  	return c
  6953  }
  6954  
  6955  // Fields allows partial responses to be retrieved. See
  6956  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  6957  // details.
  6958  func (c *DeploymentsDevicesUpdateSignedCall) Fields(s ...googleapi.Field) *DeploymentsDevicesUpdateSignedCall {
  6959  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  6960  	return c
  6961  }
  6962  
  6963  // Context sets the context to be used in this call's Do method.
  6964  func (c *DeploymentsDevicesUpdateSignedCall) Context(ctx context.Context) *DeploymentsDevicesUpdateSignedCall {
  6965  	c.ctx_ = ctx
  6966  	return c
  6967  }
  6968  
  6969  // Header returns a http.Header that can be modified by the caller to add
  6970  // headers to the request.
  6971  func (c *DeploymentsDevicesUpdateSignedCall) Header() http.Header {
  6972  	if c.header_ == nil {
  6973  		c.header_ = make(http.Header)
  6974  	}
  6975  	return c.header_
  6976  }
  6977  
  6978  func (c *DeploymentsDevicesUpdateSignedCall) doRequest(alt string) (*http.Response, error) {
  6979  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  6980  	var body io.Reader = nil
  6981  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalupdatesigneddevicerequest)
  6982  	if err != nil {
  6983  		return nil, err
  6984  	}
  6985  	c.urlParams_.Set("alt", alt)
  6986  	c.urlParams_.Set("prettyPrint", "false")
  6987  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:updateSigned")
  6988  	urls += "?" + c.urlParams_.Encode()
  6989  	req, err := http.NewRequest("PATCH", urls, body)
  6990  	if err != nil {
  6991  		return nil, err
  6992  	}
  6993  	req.Header = reqHeaders
  6994  	googleapi.Expand(req.URL, map[string]string{
  6995  		"name": c.name,
  6996  	})
  6997  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  6998  }
  6999  
  7000  // Do executes the "sasportal.deployments.devices.updateSigned" call.
  7001  // Any non-2xx status code is an error. Response headers are in either
  7002  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  7003  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  7004  // check whether the returned error was because http.StatusNotModified was
  7005  // returned.
  7006  func (c *DeploymentsDevicesUpdateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  7007  	gensupport.SetOptions(c.urlParams_, opts...)
  7008  	res, err := c.doRequest("json")
  7009  	if res != nil && res.StatusCode == http.StatusNotModified {
  7010  		if res.Body != nil {
  7011  			res.Body.Close()
  7012  		}
  7013  		return nil, gensupport.WrapError(&googleapi.Error{
  7014  			Code:   res.StatusCode,
  7015  			Header: res.Header,
  7016  		})
  7017  	}
  7018  	if err != nil {
  7019  		return nil, err
  7020  	}
  7021  	defer googleapi.CloseBody(res)
  7022  	if err := googleapi.CheckResponse(res); err != nil {
  7023  		return nil, gensupport.WrapError(err)
  7024  	}
  7025  	ret := &SasPortalDevice{
  7026  		ServerResponse: googleapi.ServerResponse{
  7027  			Header:         res.Header,
  7028  			HTTPStatusCode: res.StatusCode,
  7029  		},
  7030  	}
  7031  	target := &ret
  7032  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7033  		return nil, err
  7034  	}
  7035  	return ret, nil
  7036  }
  7037  
  7038  type InstallerGenerateSecretCall struct {
  7039  	s                              *Service
  7040  	sasportalgeneratesecretrequest *SasPortalGenerateSecretRequest
  7041  	urlParams_                     gensupport.URLParams
  7042  	ctx_                           context.Context
  7043  	header_                        http.Header
  7044  }
  7045  
  7046  // GenerateSecret: Generates a secret to be used with the ValidateInstaller.
  7047  func (r *InstallerService) GenerateSecret(sasportalgeneratesecretrequest *SasPortalGenerateSecretRequest) *InstallerGenerateSecretCall {
  7048  	c := &InstallerGenerateSecretCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7049  	c.sasportalgeneratesecretrequest = sasportalgeneratesecretrequest
  7050  	return c
  7051  }
  7052  
  7053  // Fields allows partial responses to be retrieved. See
  7054  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7055  // details.
  7056  func (c *InstallerGenerateSecretCall) Fields(s ...googleapi.Field) *InstallerGenerateSecretCall {
  7057  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7058  	return c
  7059  }
  7060  
  7061  // Context sets the context to be used in this call's Do method.
  7062  func (c *InstallerGenerateSecretCall) Context(ctx context.Context) *InstallerGenerateSecretCall {
  7063  	c.ctx_ = ctx
  7064  	return c
  7065  }
  7066  
  7067  // Header returns a http.Header that can be modified by the caller to add
  7068  // headers to the request.
  7069  func (c *InstallerGenerateSecretCall) Header() http.Header {
  7070  	if c.header_ == nil {
  7071  		c.header_ = make(http.Header)
  7072  	}
  7073  	return c.header_
  7074  }
  7075  
  7076  func (c *InstallerGenerateSecretCall) doRequest(alt string) (*http.Response, error) {
  7077  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  7078  	var body io.Reader = nil
  7079  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalgeneratesecretrequest)
  7080  	if err != nil {
  7081  		return nil, err
  7082  	}
  7083  	c.urlParams_.Set("alt", alt)
  7084  	c.urlParams_.Set("prettyPrint", "false")
  7085  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/installer:generateSecret")
  7086  	urls += "?" + c.urlParams_.Encode()
  7087  	req, err := http.NewRequest("POST", urls, body)
  7088  	if err != nil {
  7089  		return nil, err
  7090  	}
  7091  	req.Header = reqHeaders
  7092  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7093  }
  7094  
  7095  // Do executes the "sasportal.installer.generateSecret" call.
  7096  // Any non-2xx status code is an error. Response headers are in either
  7097  // *SasPortalGenerateSecretResponse.ServerResponse.Header or (if a response was
  7098  // returned at all) in error.(*googleapi.Error).Header. Use
  7099  // googleapi.IsNotModified to check whether the returned error was because
  7100  // http.StatusNotModified was returned.
  7101  func (c *InstallerGenerateSecretCall) Do(opts ...googleapi.CallOption) (*SasPortalGenerateSecretResponse, error) {
  7102  	gensupport.SetOptions(c.urlParams_, opts...)
  7103  	res, err := c.doRequest("json")
  7104  	if res != nil && res.StatusCode == http.StatusNotModified {
  7105  		if res.Body != nil {
  7106  			res.Body.Close()
  7107  		}
  7108  		return nil, gensupport.WrapError(&googleapi.Error{
  7109  			Code:   res.StatusCode,
  7110  			Header: res.Header,
  7111  		})
  7112  	}
  7113  	if err != nil {
  7114  		return nil, err
  7115  	}
  7116  	defer googleapi.CloseBody(res)
  7117  	if err := googleapi.CheckResponse(res); err != nil {
  7118  		return nil, gensupport.WrapError(err)
  7119  	}
  7120  	ret := &SasPortalGenerateSecretResponse{
  7121  		ServerResponse: googleapi.ServerResponse{
  7122  			Header:         res.Header,
  7123  			HTTPStatusCode: res.StatusCode,
  7124  		},
  7125  	}
  7126  	target := &ret
  7127  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7128  		return nil, err
  7129  	}
  7130  	return ret, nil
  7131  }
  7132  
  7133  type InstallerValidateCall struct {
  7134  	s                                 *Service
  7135  	sasportalvalidateinstallerrequest *SasPortalValidateInstallerRequest
  7136  	urlParams_                        gensupport.URLParams
  7137  	ctx_                              context.Context
  7138  	header_                           http.Header
  7139  }
  7140  
  7141  // Validate: Validates the identity of a Certified Professional Installer
  7142  // (CPI).
  7143  func (r *InstallerService) Validate(sasportalvalidateinstallerrequest *SasPortalValidateInstallerRequest) *InstallerValidateCall {
  7144  	c := &InstallerValidateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7145  	c.sasportalvalidateinstallerrequest = sasportalvalidateinstallerrequest
  7146  	return c
  7147  }
  7148  
  7149  // Fields allows partial responses to be retrieved. See
  7150  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7151  // details.
  7152  func (c *InstallerValidateCall) Fields(s ...googleapi.Field) *InstallerValidateCall {
  7153  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7154  	return c
  7155  }
  7156  
  7157  // Context sets the context to be used in this call's Do method.
  7158  func (c *InstallerValidateCall) Context(ctx context.Context) *InstallerValidateCall {
  7159  	c.ctx_ = ctx
  7160  	return c
  7161  }
  7162  
  7163  // Header returns a http.Header that can be modified by the caller to add
  7164  // headers to the request.
  7165  func (c *InstallerValidateCall) Header() http.Header {
  7166  	if c.header_ == nil {
  7167  		c.header_ = make(http.Header)
  7168  	}
  7169  	return c.header_
  7170  }
  7171  
  7172  func (c *InstallerValidateCall) doRequest(alt string) (*http.Response, error) {
  7173  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  7174  	var body io.Reader = nil
  7175  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalvalidateinstallerrequest)
  7176  	if err != nil {
  7177  		return nil, err
  7178  	}
  7179  	c.urlParams_.Set("alt", alt)
  7180  	c.urlParams_.Set("prettyPrint", "false")
  7181  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/installer:validate")
  7182  	urls += "?" + c.urlParams_.Encode()
  7183  	req, err := http.NewRequest("POST", urls, body)
  7184  	if err != nil {
  7185  		return nil, err
  7186  	}
  7187  	req.Header = reqHeaders
  7188  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7189  }
  7190  
  7191  // Do executes the "sasportal.installer.validate" call.
  7192  // Any non-2xx status code is an error. Response headers are in either
  7193  // *SasPortalValidateInstallerResponse.ServerResponse.Header or (if a response
  7194  // was returned at all) in error.(*googleapi.Error).Header. Use
  7195  // googleapi.IsNotModified to check whether the returned error was because
  7196  // http.StatusNotModified was returned.
  7197  func (c *InstallerValidateCall) Do(opts ...googleapi.CallOption) (*SasPortalValidateInstallerResponse, error) {
  7198  	gensupport.SetOptions(c.urlParams_, opts...)
  7199  	res, err := c.doRequest("json")
  7200  	if res != nil && res.StatusCode == http.StatusNotModified {
  7201  		if res.Body != nil {
  7202  			res.Body.Close()
  7203  		}
  7204  		return nil, gensupport.WrapError(&googleapi.Error{
  7205  			Code:   res.StatusCode,
  7206  			Header: res.Header,
  7207  		})
  7208  	}
  7209  	if err != nil {
  7210  		return nil, err
  7211  	}
  7212  	defer googleapi.CloseBody(res)
  7213  	if err := googleapi.CheckResponse(res); err != nil {
  7214  		return nil, gensupport.WrapError(err)
  7215  	}
  7216  	ret := &SasPortalValidateInstallerResponse{
  7217  		ServerResponse: googleapi.ServerResponse{
  7218  			Header:         res.Header,
  7219  			HTTPStatusCode: res.StatusCode,
  7220  		},
  7221  	}
  7222  	target := &ret
  7223  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7224  		return nil, err
  7225  	}
  7226  	return ret, nil
  7227  }
  7228  
  7229  type NodesGetCall struct {
  7230  	s            *Service
  7231  	name         string
  7232  	urlParams_   gensupport.URLParams
  7233  	ifNoneMatch_ string
  7234  	ctx_         context.Context
  7235  	header_      http.Header
  7236  }
  7237  
  7238  // Get: Returns a requested node.
  7239  //
  7240  // - name: The name of the node.
  7241  func (r *NodesService) Get(name string) *NodesGetCall {
  7242  	c := &NodesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7243  	c.name = name
  7244  	return c
  7245  }
  7246  
  7247  // Fields allows partial responses to be retrieved. See
  7248  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7249  // details.
  7250  func (c *NodesGetCall) Fields(s ...googleapi.Field) *NodesGetCall {
  7251  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7252  	return c
  7253  }
  7254  
  7255  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  7256  // object's ETag matches the given value. This is useful for getting updates
  7257  // only after the object has changed since the last request.
  7258  func (c *NodesGetCall) IfNoneMatch(entityTag string) *NodesGetCall {
  7259  	c.ifNoneMatch_ = entityTag
  7260  	return c
  7261  }
  7262  
  7263  // Context sets the context to be used in this call's Do method.
  7264  func (c *NodesGetCall) Context(ctx context.Context) *NodesGetCall {
  7265  	c.ctx_ = ctx
  7266  	return c
  7267  }
  7268  
  7269  // Header returns a http.Header that can be modified by the caller to add
  7270  // headers to the request.
  7271  func (c *NodesGetCall) Header() http.Header {
  7272  	if c.header_ == nil {
  7273  		c.header_ = make(http.Header)
  7274  	}
  7275  	return c.header_
  7276  }
  7277  
  7278  func (c *NodesGetCall) doRequest(alt string) (*http.Response, error) {
  7279  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  7280  	if c.ifNoneMatch_ != "" {
  7281  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  7282  	}
  7283  	var body io.Reader = nil
  7284  	c.urlParams_.Set("alt", alt)
  7285  	c.urlParams_.Set("prettyPrint", "false")
  7286  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  7287  	urls += "?" + c.urlParams_.Encode()
  7288  	req, err := http.NewRequest("GET", urls, body)
  7289  	if err != nil {
  7290  		return nil, err
  7291  	}
  7292  	req.Header = reqHeaders
  7293  	googleapi.Expand(req.URL, map[string]string{
  7294  		"name": c.name,
  7295  	})
  7296  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7297  }
  7298  
  7299  // Do executes the "sasportal.nodes.get" call.
  7300  // Any non-2xx status code is an error. Response headers are in either
  7301  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  7302  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  7303  // whether the returned error was because http.StatusNotModified was returned.
  7304  func (c *NodesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  7305  	gensupport.SetOptions(c.urlParams_, opts...)
  7306  	res, err := c.doRequest("json")
  7307  	if res != nil && res.StatusCode == http.StatusNotModified {
  7308  		if res.Body != nil {
  7309  			res.Body.Close()
  7310  		}
  7311  		return nil, gensupport.WrapError(&googleapi.Error{
  7312  			Code:   res.StatusCode,
  7313  			Header: res.Header,
  7314  		})
  7315  	}
  7316  	if err != nil {
  7317  		return nil, err
  7318  	}
  7319  	defer googleapi.CloseBody(res)
  7320  	if err := googleapi.CheckResponse(res); err != nil {
  7321  		return nil, gensupport.WrapError(err)
  7322  	}
  7323  	ret := &SasPortalNode{
  7324  		ServerResponse: googleapi.ServerResponse{
  7325  			Header:         res.Header,
  7326  			HTTPStatusCode: res.StatusCode,
  7327  		},
  7328  	}
  7329  	target := &ret
  7330  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7331  		return nil, err
  7332  	}
  7333  	return ret, nil
  7334  }
  7335  
  7336  type NodesDeploymentsDeleteCall struct {
  7337  	s          *Service
  7338  	name       string
  7339  	urlParams_ gensupport.URLParams
  7340  	ctx_       context.Context
  7341  	header_    http.Header
  7342  }
  7343  
  7344  // Delete: Deletes a deployment.
  7345  //
  7346  // - name: The name of the deployment.
  7347  func (r *NodesDeploymentsService) Delete(name string) *NodesDeploymentsDeleteCall {
  7348  	c := &NodesDeploymentsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7349  	c.name = name
  7350  	return c
  7351  }
  7352  
  7353  // Fields allows partial responses to be retrieved. See
  7354  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7355  // details.
  7356  func (c *NodesDeploymentsDeleteCall) Fields(s ...googleapi.Field) *NodesDeploymentsDeleteCall {
  7357  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7358  	return c
  7359  }
  7360  
  7361  // Context sets the context to be used in this call's Do method.
  7362  func (c *NodesDeploymentsDeleteCall) Context(ctx context.Context) *NodesDeploymentsDeleteCall {
  7363  	c.ctx_ = ctx
  7364  	return c
  7365  }
  7366  
  7367  // Header returns a http.Header that can be modified by the caller to add
  7368  // headers to the request.
  7369  func (c *NodesDeploymentsDeleteCall) Header() http.Header {
  7370  	if c.header_ == nil {
  7371  		c.header_ = make(http.Header)
  7372  	}
  7373  	return c.header_
  7374  }
  7375  
  7376  func (c *NodesDeploymentsDeleteCall) doRequest(alt string) (*http.Response, error) {
  7377  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  7378  	var body io.Reader = nil
  7379  	c.urlParams_.Set("alt", alt)
  7380  	c.urlParams_.Set("prettyPrint", "false")
  7381  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  7382  	urls += "?" + c.urlParams_.Encode()
  7383  	req, err := http.NewRequest("DELETE", urls, body)
  7384  	if err != nil {
  7385  		return nil, err
  7386  	}
  7387  	req.Header = reqHeaders
  7388  	googleapi.Expand(req.URL, map[string]string{
  7389  		"name": c.name,
  7390  	})
  7391  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7392  }
  7393  
  7394  // Do executes the "sasportal.nodes.deployments.delete" call.
  7395  // Any non-2xx status code is an error. Response headers are in either
  7396  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  7397  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  7398  // whether the returned error was because http.StatusNotModified was returned.
  7399  func (c *NodesDeploymentsDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  7400  	gensupport.SetOptions(c.urlParams_, opts...)
  7401  	res, err := c.doRequest("json")
  7402  	if res != nil && res.StatusCode == http.StatusNotModified {
  7403  		if res.Body != nil {
  7404  			res.Body.Close()
  7405  		}
  7406  		return nil, gensupport.WrapError(&googleapi.Error{
  7407  			Code:   res.StatusCode,
  7408  			Header: res.Header,
  7409  		})
  7410  	}
  7411  	if err != nil {
  7412  		return nil, err
  7413  	}
  7414  	defer googleapi.CloseBody(res)
  7415  	if err := googleapi.CheckResponse(res); err != nil {
  7416  		return nil, gensupport.WrapError(err)
  7417  	}
  7418  	ret := &SasPortalEmpty{
  7419  		ServerResponse: googleapi.ServerResponse{
  7420  			Header:         res.Header,
  7421  			HTTPStatusCode: res.StatusCode,
  7422  		},
  7423  	}
  7424  	target := &ret
  7425  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7426  		return nil, err
  7427  	}
  7428  	return ret, nil
  7429  }
  7430  
  7431  type NodesDeploymentsGetCall struct {
  7432  	s            *Service
  7433  	name         string
  7434  	urlParams_   gensupport.URLParams
  7435  	ifNoneMatch_ string
  7436  	ctx_         context.Context
  7437  	header_      http.Header
  7438  }
  7439  
  7440  // Get: Returns a requested deployment.
  7441  //
  7442  // - name: The name of the deployment.
  7443  func (r *NodesDeploymentsService) Get(name string) *NodesDeploymentsGetCall {
  7444  	c := &NodesDeploymentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7445  	c.name = name
  7446  	return c
  7447  }
  7448  
  7449  // Fields allows partial responses to be retrieved. See
  7450  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7451  // details.
  7452  func (c *NodesDeploymentsGetCall) Fields(s ...googleapi.Field) *NodesDeploymentsGetCall {
  7453  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7454  	return c
  7455  }
  7456  
  7457  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  7458  // object's ETag matches the given value. This is useful for getting updates
  7459  // only after the object has changed since the last request.
  7460  func (c *NodesDeploymentsGetCall) IfNoneMatch(entityTag string) *NodesDeploymentsGetCall {
  7461  	c.ifNoneMatch_ = entityTag
  7462  	return c
  7463  }
  7464  
  7465  // Context sets the context to be used in this call's Do method.
  7466  func (c *NodesDeploymentsGetCall) Context(ctx context.Context) *NodesDeploymentsGetCall {
  7467  	c.ctx_ = ctx
  7468  	return c
  7469  }
  7470  
  7471  // Header returns a http.Header that can be modified by the caller to add
  7472  // headers to the request.
  7473  func (c *NodesDeploymentsGetCall) Header() http.Header {
  7474  	if c.header_ == nil {
  7475  		c.header_ = make(http.Header)
  7476  	}
  7477  	return c.header_
  7478  }
  7479  
  7480  func (c *NodesDeploymentsGetCall) doRequest(alt string) (*http.Response, error) {
  7481  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  7482  	if c.ifNoneMatch_ != "" {
  7483  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  7484  	}
  7485  	var body io.Reader = nil
  7486  	c.urlParams_.Set("alt", alt)
  7487  	c.urlParams_.Set("prettyPrint", "false")
  7488  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  7489  	urls += "?" + c.urlParams_.Encode()
  7490  	req, err := http.NewRequest("GET", urls, body)
  7491  	if err != nil {
  7492  		return nil, err
  7493  	}
  7494  	req.Header = reqHeaders
  7495  	googleapi.Expand(req.URL, map[string]string{
  7496  		"name": c.name,
  7497  	})
  7498  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7499  }
  7500  
  7501  // Do executes the "sasportal.nodes.deployments.get" call.
  7502  // Any non-2xx status code is an error. Response headers are in either
  7503  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  7504  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  7505  // check whether the returned error was because http.StatusNotModified was
  7506  // returned.
  7507  func (c *NodesDeploymentsGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  7508  	gensupport.SetOptions(c.urlParams_, opts...)
  7509  	res, err := c.doRequest("json")
  7510  	if res != nil && res.StatusCode == http.StatusNotModified {
  7511  		if res.Body != nil {
  7512  			res.Body.Close()
  7513  		}
  7514  		return nil, gensupport.WrapError(&googleapi.Error{
  7515  			Code:   res.StatusCode,
  7516  			Header: res.Header,
  7517  		})
  7518  	}
  7519  	if err != nil {
  7520  		return nil, err
  7521  	}
  7522  	defer googleapi.CloseBody(res)
  7523  	if err := googleapi.CheckResponse(res); err != nil {
  7524  		return nil, gensupport.WrapError(err)
  7525  	}
  7526  	ret := &SasPortalDeployment{
  7527  		ServerResponse: googleapi.ServerResponse{
  7528  			Header:         res.Header,
  7529  			HTTPStatusCode: res.StatusCode,
  7530  		},
  7531  	}
  7532  	target := &ret
  7533  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7534  		return nil, err
  7535  	}
  7536  	return ret, nil
  7537  }
  7538  
  7539  type NodesDeploymentsListCall struct {
  7540  	s            *Service
  7541  	parent       string
  7542  	urlParams_   gensupport.URLParams
  7543  	ifNoneMatch_ string
  7544  	ctx_         context.Context
  7545  	header_      http.Header
  7546  }
  7547  
  7548  // List: Lists deployments.
  7549  //
  7550  //   - parent: The parent resource name, for example, "nodes/1",
  7551  //     customer/1/nodes/2.
  7552  func (r *NodesDeploymentsService) List(parent string) *NodesDeploymentsListCall {
  7553  	c := &NodesDeploymentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7554  	c.parent = parent
  7555  	return c
  7556  }
  7557  
  7558  // Filter sets the optional parameter "filter": The filter expression. The
  7559  // filter should have the following format: "DIRECT_CHILDREN" or format:
  7560  // "direct_children". The filter is case insensitive. If empty, then no
  7561  // deployments are filtered.
  7562  func (c *NodesDeploymentsListCall) Filter(filter string) *NodesDeploymentsListCall {
  7563  	c.urlParams_.Set("filter", filter)
  7564  	return c
  7565  }
  7566  
  7567  // PageSize sets the optional parameter "pageSize": The maximum number of
  7568  // deployments to return in the response.
  7569  func (c *NodesDeploymentsListCall) PageSize(pageSize int64) *NodesDeploymentsListCall {
  7570  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  7571  	return c
  7572  }
  7573  
  7574  // PageToken sets the optional parameter "pageToken": A pagination token
  7575  // returned from a previous call to ListDeployments that indicates where this
  7576  // listing should continue from.
  7577  func (c *NodesDeploymentsListCall) PageToken(pageToken string) *NodesDeploymentsListCall {
  7578  	c.urlParams_.Set("pageToken", pageToken)
  7579  	return c
  7580  }
  7581  
  7582  // Fields allows partial responses to be retrieved. See
  7583  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7584  // details.
  7585  func (c *NodesDeploymentsListCall) Fields(s ...googleapi.Field) *NodesDeploymentsListCall {
  7586  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7587  	return c
  7588  }
  7589  
  7590  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  7591  // object's ETag matches the given value. This is useful for getting updates
  7592  // only after the object has changed since the last request.
  7593  func (c *NodesDeploymentsListCall) IfNoneMatch(entityTag string) *NodesDeploymentsListCall {
  7594  	c.ifNoneMatch_ = entityTag
  7595  	return c
  7596  }
  7597  
  7598  // Context sets the context to be used in this call's Do method.
  7599  func (c *NodesDeploymentsListCall) Context(ctx context.Context) *NodesDeploymentsListCall {
  7600  	c.ctx_ = ctx
  7601  	return c
  7602  }
  7603  
  7604  // Header returns a http.Header that can be modified by the caller to add
  7605  // headers to the request.
  7606  func (c *NodesDeploymentsListCall) Header() http.Header {
  7607  	if c.header_ == nil {
  7608  		c.header_ = make(http.Header)
  7609  	}
  7610  	return c.header_
  7611  }
  7612  
  7613  func (c *NodesDeploymentsListCall) doRequest(alt string) (*http.Response, error) {
  7614  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  7615  	if c.ifNoneMatch_ != "" {
  7616  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  7617  	}
  7618  	var body io.Reader = nil
  7619  	c.urlParams_.Set("alt", alt)
  7620  	c.urlParams_.Set("prettyPrint", "false")
  7621  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  7622  	urls += "?" + c.urlParams_.Encode()
  7623  	req, err := http.NewRequest("GET", urls, body)
  7624  	if err != nil {
  7625  		return nil, err
  7626  	}
  7627  	req.Header = reqHeaders
  7628  	googleapi.Expand(req.URL, map[string]string{
  7629  		"parent": c.parent,
  7630  	})
  7631  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7632  }
  7633  
  7634  // Do executes the "sasportal.nodes.deployments.list" call.
  7635  // Any non-2xx status code is an error. Response headers are in either
  7636  // *SasPortalListDeploymentsResponse.ServerResponse.Header or (if a response
  7637  // was returned at all) in error.(*googleapi.Error).Header. Use
  7638  // googleapi.IsNotModified to check whether the returned error was because
  7639  // http.StatusNotModified was returned.
  7640  func (c *NodesDeploymentsListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDeploymentsResponse, error) {
  7641  	gensupport.SetOptions(c.urlParams_, opts...)
  7642  	res, err := c.doRequest("json")
  7643  	if res != nil && res.StatusCode == http.StatusNotModified {
  7644  		if res.Body != nil {
  7645  			res.Body.Close()
  7646  		}
  7647  		return nil, gensupport.WrapError(&googleapi.Error{
  7648  			Code:   res.StatusCode,
  7649  			Header: res.Header,
  7650  		})
  7651  	}
  7652  	if err != nil {
  7653  		return nil, err
  7654  	}
  7655  	defer googleapi.CloseBody(res)
  7656  	if err := googleapi.CheckResponse(res); err != nil {
  7657  		return nil, gensupport.WrapError(err)
  7658  	}
  7659  	ret := &SasPortalListDeploymentsResponse{
  7660  		ServerResponse: googleapi.ServerResponse{
  7661  			Header:         res.Header,
  7662  			HTTPStatusCode: res.StatusCode,
  7663  		},
  7664  	}
  7665  	target := &ret
  7666  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7667  		return nil, err
  7668  	}
  7669  	return ret, nil
  7670  }
  7671  
  7672  // Pages invokes f for each page of results.
  7673  // A non-nil error returned from f will halt the iteration.
  7674  // The provided context supersedes any context provided to the Context method.
  7675  func (c *NodesDeploymentsListCall) Pages(ctx context.Context, f func(*SasPortalListDeploymentsResponse) error) error {
  7676  	c.ctx_ = ctx
  7677  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  7678  	for {
  7679  		x, err := c.Do()
  7680  		if err != nil {
  7681  			return err
  7682  		}
  7683  		if err := f(x); err != nil {
  7684  			return err
  7685  		}
  7686  		if x.NextPageToken == "" {
  7687  			return nil
  7688  		}
  7689  		c.PageToken(x.NextPageToken)
  7690  	}
  7691  }
  7692  
  7693  type NodesDeploymentsMoveCall struct {
  7694  	s                              *Service
  7695  	name                           string
  7696  	sasportalmovedeploymentrequest *SasPortalMoveDeploymentRequest
  7697  	urlParams_                     gensupport.URLParams
  7698  	ctx_                           context.Context
  7699  	header_                        http.Header
  7700  }
  7701  
  7702  // Move: Moves a deployment under another node or customer.
  7703  //
  7704  // - name: The name of the deployment to move.
  7705  func (r *NodesDeploymentsService) Move(name string, sasportalmovedeploymentrequest *SasPortalMoveDeploymentRequest) *NodesDeploymentsMoveCall {
  7706  	c := &NodesDeploymentsMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7707  	c.name = name
  7708  	c.sasportalmovedeploymentrequest = sasportalmovedeploymentrequest
  7709  	return c
  7710  }
  7711  
  7712  // Fields allows partial responses to be retrieved. See
  7713  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7714  // details.
  7715  func (c *NodesDeploymentsMoveCall) Fields(s ...googleapi.Field) *NodesDeploymentsMoveCall {
  7716  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7717  	return c
  7718  }
  7719  
  7720  // Context sets the context to be used in this call's Do method.
  7721  func (c *NodesDeploymentsMoveCall) Context(ctx context.Context) *NodesDeploymentsMoveCall {
  7722  	c.ctx_ = ctx
  7723  	return c
  7724  }
  7725  
  7726  // Header returns a http.Header that can be modified by the caller to add
  7727  // headers to the request.
  7728  func (c *NodesDeploymentsMoveCall) Header() http.Header {
  7729  	if c.header_ == nil {
  7730  		c.header_ = make(http.Header)
  7731  	}
  7732  	return c.header_
  7733  }
  7734  
  7735  func (c *NodesDeploymentsMoveCall) doRequest(alt string) (*http.Response, error) {
  7736  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  7737  	var body io.Reader = nil
  7738  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovedeploymentrequest)
  7739  	if err != nil {
  7740  		return nil, err
  7741  	}
  7742  	c.urlParams_.Set("alt", alt)
  7743  	c.urlParams_.Set("prettyPrint", "false")
  7744  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  7745  	urls += "?" + c.urlParams_.Encode()
  7746  	req, err := http.NewRequest("POST", urls, body)
  7747  	if err != nil {
  7748  		return nil, err
  7749  	}
  7750  	req.Header = reqHeaders
  7751  	googleapi.Expand(req.URL, map[string]string{
  7752  		"name": c.name,
  7753  	})
  7754  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7755  }
  7756  
  7757  // Do executes the "sasportal.nodes.deployments.move" call.
  7758  // Any non-2xx status code is an error. Response headers are in either
  7759  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  7760  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  7761  // check whether the returned error was because http.StatusNotModified was
  7762  // returned.
  7763  func (c *NodesDeploymentsMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  7764  	gensupport.SetOptions(c.urlParams_, opts...)
  7765  	res, err := c.doRequest("json")
  7766  	if res != nil && res.StatusCode == http.StatusNotModified {
  7767  		if res.Body != nil {
  7768  			res.Body.Close()
  7769  		}
  7770  		return nil, gensupport.WrapError(&googleapi.Error{
  7771  			Code:   res.StatusCode,
  7772  			Header: res.Header,
  7773  		})
  7774  	}
  7775  	if err != nil {
  7776  		return nil, err
  7777  	}
  7778  	defer googleapi.CloseBody(res)
  7779  	if err := googleapi.CheckResponse(res); err != nil {
  7780  		return nil, gensupport.WrapError(err)
  7781  	}
  7782  	ret := &SasPortalOperation{
  7783  		ServerResponse: googleapi.ServerResponse{
  7784  			Header:         res.Header,
  7785  			HTTPStatusCode: res.StatusCode,
  7786  		},
  7787  	}
  7788  	target := &ret
  7789  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7790  		return nil, err
  7791  	}
  7792  	return ret, nil
  7793  }
  7794  
  7795  type NodesDeploymentsPatchCall struct {
  7796  	s                   *Service
  7797  	name                string
  7798  	sasportaldeployment *SasPortalDeployment
  7799  	urlParams_          gensupport.URLParams
  7800  	ctx_                context.Context
  7801  	header_             http.Header
  7802  }
  7803  
  7804  // Patch: Updates an existing deployment.
  7805  //
  7806  // - name: Output only. Resource name.
  7807  func (r *NodesDeploymentsService) Patch(name string, sasportaldeployment *SasPortalDeployment) *NodesDeploymentsPatchCall {
  7808  	c := &NodesDeploymentsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7809  	c.name = name
  7810  	c.sasportaldeployment = sasportaldeployment
  7811  	return c
  7812  }
  7813  
  7814  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  7815  func (c *NodesDeploymentsPatchCall) UpdateMask(updateMask string) *NodesDeploymentsPatchCall {
  7816  	c.urlParams_.Set("updateMask", updateMask)
  7817  	return c
  7818  }
  7819  
  7820  // Fields allows partial responses to be retrieved. See
  7821  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7822  // details.
  7823  func (c *NodesDeploymentsPatchCall) Fields(s ...googleapi.Field) *NodesDeploymentsPatchCall {
  7824  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7825  	return c
  7826  }
  7827  
  7828  // Context sets the context to be used in this call's Do method.
  7829  func (c *NodesDeploymentsPatchCall) Context(ctx context.Context) *NodesDeploymentsPatchCall {
  7830  	c.ctx_ = ctx
  7831  	return c
  7832  }
  7833  
  7834  // Header returns a http.Header that can be modified by the caller to add
  7835  // headers to the request.
  7836  func (c *NodesDeploymentsPatchCall) Header() http.Header {
  7837  	if c.header_ == nil {
  7838  		c.header_ = make(http.Header)
  7839  	}
  7840  	return c.header_
  7841  }
  7842  
  7843  func (c *NodesDeploymentsPatchCall) doRequest(alt string) (*http.Response, error) {
  7844  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  7845  	var body io.Reader = nil
  7846  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldeployment)
  7847  	if err != nil {
  7848  		return nil, err
  7849  	}
  7850  	c.urlParams_.Set("alt", alt)
  7851  	c.urlParams_.Set("prettyPrint", "false")
  7852  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  7853  	urls += "?" + c.urlParams_.Encode()
  7854  	req, err := http.NewRequest("PATCH", urls, body)
  7855  	if err != nil {
  7856  		return nil, err
  7857  	}
  7858  	req.Header = reqHeaders
  7859  	googleapi.Expand(req.URL, map[string]string{
  7860  		"name": c.name,
  7861  	})
  7862  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7863  }
  7864  
  7865  // Do executes the "sasportal.nodes.deployments.patch" call.
  7866  // Any non-2xx status code is an error. Response headers are in either
  7867  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  7868  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  7869  // check whether the returned error was because http.StatusNotModified was
  7870  // returned.
  7871  func (c *NodesDeploymentsPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  7872  	gensupport.SetOptions(c.urlParams_, opts...)
  7873  	res, err := c.doRequest("json")
  7874  	if res != nil && res.StatusCode == http.StatusNotModified {
  7875  		if res.Body != nil {
  7876  			res.Body.Close()
  7877  		}
  7878  		return nil, gensupport.WrapError(&googleapi.Error{
  7879  			Code:   res.StatusCode,
  7880  			Header: res.Header,
  7881  		})
  7882  	}
  7883  	if err != nil {
  7884  		return nil, err
  7885  	}
  7886  	defer googleapi.CloseBody(res)
  7887  	if err := googleapi.CheckResponse(res); err != nil {
  7888  		return nil, gensupport.WrapError(err)
  7889  	}
  7890  	ret := &SasPortalDeployment{
  7891  		ServerResponse: googleapi.ServerResponse{
  7892  			Header:         res.Header,
  7893  			HTTPStatusCode: res.StatusCode,
  7894  		},
  7895  	}
  7896  	target := &ret
  7897  	if err := gensupport.DecodeResponse(target, res); err != nil {
  7898  		return nil, err
  7899  	}
  7900  	return ret, nil
  7901  }
  7902  
  7903  type NodesDeploymentsDevicesCreateCall struct {
  7904  	s               *Service
  7905  	parent          string
  7906  	sasportaldevice *SasPortalDevice
  7907  	urlParams_      gensupport.URLParams
  7908  	ctx_            context.Context
  7909  	header_         http.Header
  7910  }
  7911  
  7912  // Create: Creates a device under a node or customer.
  7913  //
  7914  // - parent: The name of the parent resource.
  7915  func (r *NodesDeploymentsDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *NodesDeploymentsDevicesCreateCall {
  7916  	c := &NodesDeploymentsDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  7917  	c.parent = parent
  7918  	c.sasportaldevice = sasportaldevice
  7919  	return c
  7920  }
  7921  
  7922  // Fields allows partial responses to be retrieved. See
  7923  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  7924  // details.
  7925  func (c *NodesDeploymentsDevicesCreateCall) Fields(s ...googleapi.Field) *NodesDeploymentsDevicesCreateCall {
  7926  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  7927  	return c
  7928  }
  7929  
  7930  // Context sets the context to be used in this call's Do method.
  7931  func (c *NodesDeploymentsDevicesCreateCall) Context(ctx context.Context) *NodesDeploymentsDevicesCreateCall {
  7932  	c.ctx_ = ctx
  7933  	return c
  7934  }
  7935  
  7936  // Header returns a http.Header that can be modified by the caller to add
  7937  // headers to the request.
  7938  func (c *NodesDeploymentsDevicesCreateCall) Header() http.Header {
  7939  	if c.header_ == nil {
  7940  		c.header_ = make(http.Header)
  7941  	}
  7942  	return c.header_
  7943  }
  7944  
  7945  func (c *NodesDeploymentsDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
  7946  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  7947  	var body io.Reader = nil
  7948  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  7949  	if err != nil {
  7950  		return nil, err
  7951  	}
  7952  	c.urlParams_.Set("alt", alt)
  7953  	c.urlParams_.Set("prettyPrint", "false")
  7954  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  7955  	urls += "?" + c.urlParams_.Encode()
  7956  	req, err := http.NewRequest("POST", urls, body)
  7957  	if err != nil {
  7958  		return nil, err
  7959  	}
  7960  	req.Header = reqHeaders
  7961  	googleapi.Expand(req.URL, map[string]string{
  7962  		"parent": c.parent,
  7963  	})
  7964  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  7965  }
  7966  
  7967  // Do executes the "sasportal.nodes.deployments.devices.create" call.
  7968  // Any non-2xx status code is an error. Response headers are in either
  7969  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  7970  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  7971  // check whether the returned error was because http.StatusNotModified was
  7972  // returned.
  7973  func (c *NodesDeploymentsDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  7974  	gensupport.SetOptions(c.urlParams_, opts...)
  7975  	res, err := c.doRequest("json")
  7976  	if res != nil && res.StatusCode == http.StatusNotModified {
  7977  		if res.Body != nil {
  7978  			res.Body.Close()
  7979  		}
  7980  		return nil, gensupport.WrapError(&googleapi.Error{
  7981  			Code:   res.StatusCode,
  7982  			Header: res.Header,
  7983  		})
  7984  	}
  7985  	if err != nil {
  7986  		return nil, err
  7987  	}
  7988  	defer googleapi.CloseBody(res)
  7989  	if err := googleapi.CheckResponse(res); err != nil {
  7990  		return nil, gensupport.WrapError(err)
  7991  	}
  7992  	ret := &SasPortalDevice{
  7993  		ServerResponse: googleapi.ServerResponse{
  7994  			Header:         res.Header,
  7995  			HTTPStatusCode: res.StatusCode,
  7996  		},
  7997  	}
  7998  	target := &ret
  7999  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8000  		return nil, err
  8001  	}
  8002  	return ret, nil
  8003  }
  8004  
  8005  type NodesDeploymentsDevicesCreateSignedCall struct {
  8006  	s                                  *Service
  8007  	parent                             string
  8008  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
  8009  	urlParams_                         gensupport.URLParams
  8010  	ctx_                               context.Context
  8011  	header_                            http.Header
  8012  }
  8013  
  8014  // CreateSigned: Creates a signed device under a node or customer.
  8015  //
  8016  // - parent: The name of the parent resource.
  8017  func (r *NodesDeploymentsDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *NodesDeploymentsDevicesCreateSignedCall {
  8018  	c := &NodesDeploymentsDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8019  	c.parent = parent
  8020  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
  8021  	return c
  8022  }
  8023  
  8024  // Fields allows partial responses to be retrieved. See
  8025  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8026  // details.
  8027  func (c *NodesDeploymentsDevicesCreateSignedCall) Fields(s ...googleapi.Field) *NodesDeploymentsDevicesCreateSignedCall {
  8028  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8029  	return c
  8030  }
  8031  
  8032  // Context sets the context to be used in this call's Do method.
  8033  func (c *NodesDeploymentsDevicesCreateSignedCall) Context(ctx context.Context) *NodesDeploymentsDevicesCreateSignedCall {
  8034  	c.ctx_ = ctx
  8035  	return c
  8036  }
  8037  
  8038  // Header returns a http.Header that can be modified by the caller to add
  8039  // headers to the request.
  8040  func (c *NodesDeploymentsDevicesCreateSignedCall) Header() http.Header {
  8041  	if c.header_ == nil {
  8042  		c.header_ = make(http.Header)
  8043  	}
  8044  	return c.header_
  8045  }
  8046  
  8047  func (c *NodesDeploymentsDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
  8048  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  8049  	var body io.Reader = nil
  8050  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
  8051  	if err != nil {
  8052  		return nil, err
  8053  	}
  8054  	c.urlParams_.Set("alt", alt)
  8055  	c.urlParams_.Set("prettyPrint", "false")
  8056  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
  8057  	urls += "?" + c.urlParams_.Encode()
  8058  	req, err := http.NewRequest("POST", urls, body)
  8059  	if err != nil {
  8060  		return nil, err
  8061  	}
  8062  	req.Header = reqHeaders
  8063  	googleapi.Expand(req.URL, map[string]string{
  8064  		"parent": c.parent,
  8065  	})
  8066  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8067  }
  8068  
  8069  // Do executes the "sasportal.nodes.deployments.devices.createSigned" call.
  8070  // Any non-2xx status code is an error. Response headers are in either
  8071  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  8072  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8073  // check whether the returned error was because http.StatusNotModified was
  8074  // returned.
  8075  func (c *NodesDeploymentsDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  8076  	gensupport.SetOptions(c.urlParams_, opts...)
  8077  	res, err := c.doRequest("json")
  8078  	if res != nil && res.StatusCode == http.StatusNotModified {
  8079  		if res.Body != nil {
  8080  			res.Body.Close()
  8081  		}
  8082  		return nil, gensupport.WrapError(&googleapi.Error{
  8083  			Code:   res.StatusCode,
  8084  			Header: res.Header,
  8085  		})
  8086  	}
  8087  	if err != nil {
  8088  		return nil, err
  8089  	}
  8090  	defer googleapi.CloseBody(res)
  8091  	if err := googleapi.CheckResponse(res); err != nil {
  8092  		return nil, gensupport.WrapError(err)
  8093  	}
  8094  	ret := &SasPortalDevice{
  8095  		ServerResponse: googleapi.ServerResponse{
  8096  			Header:         res.Header,
  8097  			HTTPStatusCode: res.StatusCode,
  8098  		},
  8099  	}
  8100  	target := &ret
  8101  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8102  		return nil, err
  8103  	}
  8104  	return ret, nil
  8105  }
  8106  
  8107  type NodesDeploymentsDevicesListCall struct {
  8108  	s            *Service
  8109  	parent       string
  8110  	urlParams_   gensupport.URLParams
  8111  	ifNoneMatch_ string
  8112  	ctx_         context.Context
  8113  	header_      http.Header
  8114  }
  8115  
  8116  // List: Lists devices under a node or customer.
  8117  //
  8118  // - parent: The name of the parent resource.
  8119  func (r *NodesDeploymentsDevicesService) List(parent string) *NodesDeploymentsDevicesListCall {
  8120  	c := &NodesDeploymentsDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8121  	c.parent = parent
  8122  	return c
  8123  }
  8124  
  8125  // Filter sets the optional parameter "filter": The filter expression. The
  8126  // filter should have one of the following formats: "sn=123454" or
  8127  // "display_name=MyDevice". sn corresponds to serial number of the device. The
  8128  // filter is case insensitive.
  8129  func (c *NodesDeploymentsDevicesListCall) Filter(filter string) *NodesDeploymentsDevicesListCall {
  8130  	c.urlParams_.Set("filter", filter)
  8131  	return c
  8132  }
  8133  
  8134  // PageSize sets the optional parameter "pageSize": The maximum number of
  8135  // devices to return in the response. If empty or zero, all devices will be
  8136  // listed. Must be in the range [0, 1000].
  8137  func (c *NodesDeploymentsDevicesListCall) PageSize(pageSize int64) *NodesDeploymentsDevicesListCall {
  8138  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  8139  	return c
  8140  }
  8141  
  8142  // PageToken sets the optional parameter "pageToken": A pagination token
  8143  // returned from a previous call to ListDevices that indicates where this
  8144  // listing should continue from.
  8145  func (c *NodesDeploymentsDevicesListCall) PageToken(pageToken string) *NodesDeploymentsDevicesListCall {
  8146  	c.urlParams_.Set("pageToken", pageToken)
  8147  	return c
  8148  }
  8149  
  8150  // Fields allows partial responses to be retrieved. See
  8151  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8152  // details.
  8153  func (c *NodesDeploymentsDevicesListCall) Fields(s ...googleapi.Field) *NodesDeploymentsDevicesListCall {
  8154  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8155  	return c
  8156  }
  8157  
  8158  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  8159  // object's ETag matches the given value. This is useful for getting updates
  8160  // only after the object has changed since the last request.
  8161  func (c *NodesDeploymentsDevicesListCall) IfNoneMatch(entityTag string) *NodesDeploymentsDevicesListCall {
  8162  	c.ifNoneMatch_ = entityTag
  8163  	return c
  8164  }
  8165  
  8166  // Context sets the context to be used in this call's Do method.
  8167  func (c *NodesDeploymentsDevicesListCall) Context(ctx context.Context) *NodesDeploymentsDevicesListCall {
  8168  	c.ctx_ = ctx
  8169  	return c
  8170  }
  8171  
  8172  // Header returns a http.Header that can be modified by the caller to add
  8173  // headers to the request.
  8174  func (c *NodesDeploymentsDevicesListCall) Header() http.Header {
  8175  	if c.header_ == nil {
  8176  		c.header_ = make(http.Header)
  8177  	}
  8178  	return c.header_
  8179  }
  8180  
  8181  func (c *NodesDeploymentsDevicesListCall) doRequest(alt string) (*http.Response, error) {
  8182  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  8183  	if c.ifNoneMatch_ != "" {
  8184  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  8185  	}
  8186  	var body io.Reader = nil
  8187  	c.urlParams_.Set("alt", alt)
  8188  	c.urlParams_.Set("prettyPrint", "false")
  8189  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  8190  	urls += "?" + c.urlParams_.Encode()
  8191  	req, err := http.NewRequest("GET", urls, body)
  8192  	if err != nil {
  8193  		return nil, err
  8194  	}
  8195  	req.Header = reqHeaders
  8196  	googleapi.Expand(req.URL, map[string]string{
  8197  		"parent": c.parent,
  8198  	})
  8199  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8200  }
  8201  
  8202  // Do executes the "sasportal.nodes.deployments.devices.list" call.
  8203  // Any non-2xx status code is an error. Response headers are in either
  8204  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
  8205  // returned at all) in error.(*googleapi.Error).Header. Use
  8206  // googleapi.IsNotModified to check whether the returned error was because
  8207  // http.StatusNotModified was returned.
  8208  func (c *NodesDeploymentsDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
  8209  	gensupport.SetOptions(c.urlParams_, opts...)
  8210  	res, err := c.doRequest("json")
  8211  	if res != nil && res.StatusCode == http.StatusNotModified {
  8212  		if res.Body != nil {
  8213  			res.Body.Close()
  8214  		}
  8215  		return nil, gensupport.WrapError(&googleapi.Error{
  8216  			Code:   res.StatusCode,
  8217  			Header: res.Header,
  8218  		})
  8219  	}
  8220  	if err != nil {
  8221  		return nil, err
  8222  	}
  8223  	defer googleapi.CloseBody(res)
  8224  	if err := googleapi.CheckResponse(res); err != nil {
  8225  		return nil, gensupport.WrapError(err)
  8226  	}
  8227  	ret := &SasPortalListDevicesResponse{
  8228  		ServerResponse: googleapi.ServerResponse{
  8229  			Header:         res.Header,
  8230  			HTTPStatusCode: res.StatusCode,
  8231  		},
  8232  	}
  8233  	target := &ret
  8234  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8235  		return nil, err
  8236  	}
  8237  	return ret, nil
  8238  }
  8239  
  8240  // Pages invokes f for each page of results.
  8241  // A non-nil error returned from f will halt the iteration.
  8242  // The provided context supersedes any context provided to the Context method.
  8243  func (c *NodesDeploymentsDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
  8244  	c.ctx_ = ctx
  8245  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  8246  	for {
  8247  		x, err := c.Do()
  8248  		if err != nil {
  8249  			return err
  8250  		}
  8251  		if err := f(x); err != nil {
  8252  			return err
  8253  		}
  8254  		if x.NextPageToken == "" {
  8255  			return nil
  8256  		}
  8257  		c.PageToken(x.NextPageToken)
  8258  	}
  8259  }
  8260  
  8261  type NodesDevicesCreateCall struct {
  8262  	s               *Service
  8263  	parent          string
  8264  	sasportaldevice *SasPortalDevice
  8265  	urlParams_      gensupport.URLParams
  8266  	ctx_            context.Context
  8267  	header_         http.Header
  8268  }
  8269  
  8270  // Create: Creates a device under a node or customer.
  8271  //
  8272  // - parent: The name of the parent resource.
  8273  func (r *NodesDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *NodesDevicesCreateCall {
  8274  	c := &NodesDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8275  	c.parent = parent
  8276  	c.sasportaldevice = sasportaldevice
  8277  	return c
  8278  }
  8279  
  8280  // Fields allows partial responses to be retrieved. See
  8281  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8282  // details.
  8283  func (c *NodesDevicesCreateCall) Fields(s ...googleapi.Field) *NodesDevicesCreateCall {
  8284  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8285  	return c
  8286  }
  8287  
  8288  // Context sets the context to be used in this call's Do method.
  8289  func (c *NodesDevicesCreateCall) Context(ctx context.Context) *NodesDevicesCreateCall {
  8290  	c.ctx_ = ctx
  8291  	return c
  8292  }
  8293  
  8294  // Header returns a http.Header that can be modified by the caller to add
  8295  // headers to the request.
  8296  func (c *NodesDevicesCreateCall) Header() http.Header {
  8297  	if c.header_ == nil {
  8298  		c.header_ = make(http.Header)
  8299  	}
  8300  	return c.header_
  8301  }
  8302  
  8303  func (c *NodesDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
  8304  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  8305  	var body io.Reader = nil
  8306  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  8307  	if err != nil {
  8308  		return nil, err
  8309  	}
  8310  	c.urlParams_.Set("alt", alt)
  8311  	c.urlParams_.Set("prettyPrint", "false")
  8312  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  8313  	urls += "?" + c.urlParams_.Encode()
  8314  	req, err := http.NewRequest("POST", urls, body)
  8315  	if err != nil {
  8316  		return nil, err
  8317  	}
  8318  	req.Header = reqHeaders
  8319  	googleapi.Expand(req.URL, map[string]string{
  8320  		"parent": c.parent,
  8321  	})
  8322  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8323  }
  8324  
  8325  // Do executes the "sasportal.nodes.devices.create" call.
  8326  // Any non-2xx status code is an error. Response headers are in either
  8327  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  8328  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8329  // check whether the returned error was because http.StatusNotModified was
  8330  // returned.
  8331  func (c *NodesDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  8332  	gensupport.SetOptions(c.urlParams_, opts...)
  8333  	res, err := c.doRequest("json")
  8334  	if res != nil && res.StatusCode == http.StatusNotModified {
  8335  		if res.Body != nil {
  8336  			res.Body.Close()
  8337  		}
  8338  		return nil, gensupport.WrapError(&googleapi.Error{
  8339  			Code:   res.StatusCode,
  8340  			Header: res.Header,
  8341  		})
  8342  	}
  8343  	if err != nil {
  8344  		return nil, err
  8345  	}
  8346  	defer googleapi.CloseBody(res)
  8347  	if err := googleapi.CheckResponse(res); err != nil {
  8348  		return nil, gensupport.WrapError(err)
  8349  	}
  8350  	ret := &SasPortalDevice{
  8351  		ServerResponse: googleapi.ServerResponse{
  8352  			Header:         res.Header,
  8353  			HTTPStatusCode: res.StatusCode,
  8354  		},
  8355  	}
  8356  	target := &ret
  8357  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8358  		return nil, err
  8359  	}
  8360  	return ret, nil
  8361  }
  8362  
  8363  type NodesDevicesCreateSignedCall struct {
  8364  	s                                  *Service
  8365  	parent                             string
  8366  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
  8367  	urlParams_                         gensupport.URLParams
  8368  	ctx_                               context.Context
  8369  	header_                            http.Header
  8370  }
  8371  
  8372  // CreateSigned: Creates a signed device under a node or customer.
  8373  //
  8374  // - parent: The name of the parent resource.
  8375  func (r *NodesDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *NodesDevicesCreateSignedCall {
  8376  	c := &NodesDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8377  	c.parent = parent
  8378  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
  8379  	return c
  8380  }
  8381  
  8382  // Fields allows partial responses to be retrieved. See
  8383  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8384  // details.
  8385  func (c *NodesDevicesCreateSignedCall) Fields(s ...googleapi.Field) *NodesDevicesCreateSignedCall {
  8386  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8387  	return c
  8388  }
  8389  
  8390  // Context sets the context to be used in this call's Do method.
  8391  func (c *NodesDevicesCreateSignedCall) Context(ctx context.Context) *NodesDevicesCreateSignedCall {
  8392  	c.ctx_ = ctx
  8393  	return c
  8394  }
  8395  
  8396  // Header returns a http.Header that can be modified by the caller to add
  8397  // headers to the request.
  8398  func (c *NodesDevicesCreateSignedCall) Header() http.Header {
  8399  	if c.header_ == nil {
  8400  		c.header_ = make(http.Header)
  8401  	}
  8402  	return c.header_
  8403  }
  8404  
  8405  func (c *NodesDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
  8406  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  8407  	var body io.Reader = nil
  8408  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
  8409  	if err != nil {
  8410  		return nil, err
  8411  	}
  8412  	c.urlParams_.Set("alt", alt)
  8413  	c.urlParams_.Set("prettyPrint", "false")
  8414  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
  8415  	urls += "?" + c.urlParams_.Encode()
  8416  	req, err := http.NewRequest("POST", urls, body)
  8417  	if err != nil {
  8418  		return nil, err
  8419  	}
  8420  	req.Header = reqHeaders
  8421  	googleapi.Expand(req.URL, map[string]string{
  8422  		"parent": c.parent,
  8423  	})
  8424  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8425  }
  8426  
  8427  // Do executes the "sasportal.nodes.devices.createSigned" call.
  8428  // Any non-2xx status code is an error. Response headers are in either
  8429  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  8430  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8431  // check whether the returned error was because http.StatusNotModified was
  8432  // returned.
  8433  func (c *NodesDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  8434  	gensupport.SetOptions(c.urlParams_, opts...)
  8435  	res, err := c.doRequest("json")
  8436  	if res != nil && res.StatusCode == http.StatusNotModified {
  8437  		if res.Body != nil {
  8438  			res.Body.Close()
  8439  		}
  8440  		return nil, gensupport.WrapError(&googleapi.Error{
  8441  			Code:   res.StatusCode,
  8442  			Header: res.Header,
  8443  		})
  8444  	}
  8445  	if err != nil {
  8446  		return nil, err
  8447  	}
  8448  	defer googleapi.CloseBody(res)
  8449  	if err := googleapi.CheckResponse(res); err != nil {
  8450  		return nil, gensupport.WrapError(err)
  8451  	}
  8452  	ret := &SasPortalDevice{
  8453  		ServerResponse: googleapi.ServerResponse{
  8454  			Header:         res.Header,
  8455  			HTTPStatusCode: res.StatusCode,
  8456  		},
  8457  	}
  8458  	target := &ret
  8459  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8460  		return nil, err
  8461  	}
  8462  	return ret, nil
  8463  }
  8464  
  8465  type NodesDevicesDeleteCall struct {
  8466  	s          *Service
  8467  	name       string
  8468  	urlParams_ gensupport.URLParams
  8469  	ctx_       context.Context
  8470  	header_    http.Header
  8471  }
  8472  
  8473  // Delete: Deletes a device.
  8474  //
  8475  // - name: The name of the device.
  8476  func (r *NodesDevicesService) Delete(name string) *NodesDevicesDeleteCall {
  8477  	c := &NodesDevicesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8478  	c.name = name
  8479  	return c
  8480  }
  8481  
  8482  // Fields allows partial responses to be retrieved. See
  8483  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8484  // details.
  8485  func (c *NodesDevicesDeleteCall) Fields(s ...googleapi.Field) *NodesDevicesDeleteCall {
  8486  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8487  	return c
  8488  }
  8489  
  8490  // Context sets the context to be used in this call's Do method.
  8491  func (c *NodesDevicesDeleteCall) Context(ctx context.Context) *NodesDevicesDeleteCall {
  8492  	c.ctx_ = ctx
  8493  	return c
  8494  }
  8495  
  8496  // Header returns a http.Header that can be modified by the caller to add
  8497  // headers to the request.
  8498  func (c *NodesDevicesDeleteCall) Header() http.Header {
  8499  	if c.header_ == nil {
  8500  		c.header_ = make(http.Header)
  8501  	}
  8502  	return c.header_
  8503  }
  8504  
  8505  func (c *NodesDevicesDeleteCall) doRequest(alt string) (*http.Response, error) {
  8506  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  8507  	var body io.Reader = nil
  8508  	c.urlParams_.Set("alt", alt)
  8509  	c.urlParams_.Set("prettyPrint", "false")
  8510  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  8511  	urls += "?" + c.urlParams_.Encode()
  8512  	req, err := http.NewRequest("DELETE", urls, body)
  8513  	if err != nil {
  8514  		return nil, err
  8515  	}
  8516  	req.Header = reqHeaders
  8517  	googleapi.Expand(req.URL, map[string]string{
  8518  		"name": c.name,
  8519  	})
  8520  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8521  }
  8522  
  8523  // Do executes the "sasportal.nodes.devices.delete" call.
  8524  // Any non-2xx status code is an error. Response headers are in either
  8525  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  8526  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  8527  // whether the returned error was because http.StatusNotModified was returned.
  8528  func (c *NodesDevicesDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  8529  	gensupport.SetOptions(c.urlParams_, opts...)
  8530  	res, err := c.doRequest("json")
  8531  	if res != nil && res.StatusCode == http.StatusNotModified {
  8532  		if res.Body != nil {
  8533  			res.Body.Close()
  8534  		}
  8535  		return nil, gensupport.WrapError(&googleapi.Error{
  8536  			Code:   res.StatusCode,
  8537  			Header: res.Header,
  8538  		})
  8539  	}
  8540  	if err != nil {
  8541  		return nil, err
  8542  	}
  8543  	defer googleapi.CloseBody(res)
  8544  	if err := googleapi.CheckResponse(res); err != nil {
  8545  		return nil, gensupport.WrapError(err)
  8546  	}
  8547  	ret := &SasPortalEmpty{
  8548  		ServerResponse: googleapi.ServerResponse{
  8549  			Header:         res.Header,
  8550  			HTTPStatusCode: res.StatusCode,
  8551  		},
  8552  	}
  8553  	target := &ret
  8554  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8555  		return nil, err
  8556  	}
  8557  	return ret, nil
  8558  }
  8559  
  8560  type NodesDevicesGetCall struct {
  8561  	s            *Service
  8562  	name         string
  8563  	urlParams_   gensupport.URLParams
  8564  	ifNoneMatch_ string
  8565  	ctx_         context.Context
  8566  	header_      http.Header
  8567  }
  8568  
  8569  // Get: Gets details about a device.
  8570  //
  8571  // - name: The name of the device.
  8572  func (r *NodesDevicesService) Get(name string) *NodesDevicesGetCall {
  8573  	c := &NodesDevicesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8574  	c.name = name
  8575  	return c
  8576  }
  8577  
  8578  // Fields allows partial responses to be retrieved. See
  8579  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8580  // details.
  8581  func (c *NodesDevicesGetCall) Fields(s ...googleapi.Field) *NodesDevicesGetCall {
  8582  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8583  	return c
  8584  }
  8585  
  8586  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  8587  // object's ETag matches the given value. This is useful for getting updates
  8588  // only after the object has changed since the last request.
  8589  func (c *NodesDevicesGetCall) IfNoneMatch(entityTag string) *NodesDevicesGetCall {
  8590  	c.ifNoneMatch_ = entityTag
  8591  	return c
  8592  }
  8593  
  8594  // Context sets the context to be used in this call's Do method.
  8595  func (c *NodesDevicesGetCall) Context(ctx context.Context) *NodesDevicesGetCall {
  8596  	c.ctx_ = ctx
  8597  	return c
  8598  }
  8599  
  8600  // Header returns a http.Header that can be modified by the caller to add
  8601  // headers to the request.
  8602  func (c *NodesDevicesGetCall) Header() http.Header {
  8603  	if c.header_ == nil {
  8604  		c.header_ = make(http.Header)
  8605  	}
  8606  	return c.header_
  8607  }
  8608  
  8609  func (c *NodesDevicesGetCall) doRequest(alt string) (*http.Response, error) {
  8610  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  8611  	if c.ifNoneMatch_ != "" {
  8612  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  8613  	}
  8614  	var body io.Reader = nil
  8615  	c.urlParams_.Set("alt", alt)
  8616  	c.urlParams_.Set("prettyPrint", "false")
  8617  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  8618  	urls += "?" + c.urlParams_.Encode()
  8619  	req, err := http.NewRequest("GET", urls, body)
  8620  	if err != nil {
  8621  		return nil, err
  8622  	}
  8623  	req.Header = reqHeaders
  8624  	googleapi.Expand(req.URL, map[string]string{
  8625  		"name": c.name,
  8626  	})
  8627  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8628  }
  8629  
  8630  // Do executes the "sasportal.nodes.devices.get" call.
  8631  // Any non-2xx status code is an error. Response headers are in either
  8632  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  8633  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8634  // check whether the returned error was because http.StatusNotModified was
  8635  // returned.
  8636  func (c *NodesDevicesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  8637  	gensupport.SetOptions(c.urlParams_, opts...)
  8638  	res, err := c.doRequest("json")
  8639  	if res != nil && res.StatusCode == http.StatusNotModified {
  8640  		if res.Body != nil {
  8641  			res.Body.Close()
  8642  		}
  8643  		return nil, gensupport.WrapError(&googleapi.Error{
  8644  			Code:   res.StatusCode,
  8645  			Header: res.Header,
  8646  		})
  8647  	}
  8648  	if err != nil {
  8649  		return nil, err
  8650  	}
  8651  	defer googleapi.CloseBody(res)
  8652  	if err := googleapi.CheckResponse(res); err != nil {
  8653  		return nil, gensupport.WrapError(err)
  8654  	}
  8655  	ret := &SasPortalDevice{
  8656  		ServerResponse: googleapi.ServerResponse{
  8657  			Header:         res.Header,
  8658  			HTTPStatusCode: res.StatusCode,
  8659  		},
  8660  	}
  8661  	target := &ret
  8662  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8663  		return nil, err
  8664  	}
  8665  	return ret, nil
  8666  }
  8667  
  8668  type NodesDevicesListCall struct {
  8669  	s            *Service
  8670  	parent       string
  8671  	urlParams_   gensupport.URLParams
  8672  	ifNoneMatch_ string
  8673  	ctx_         context.Context
  8674  	header_      http.Header
  8675  }
  8676  
  8677  // List: Lists devices under a node or customer.
  8678  //
  8679  // - parent: The name of the parent resource.
  8680  func (r *NodesDevicesService) List(parent string) *NodesDevicesListCall {
  8681  	c := &NodesDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8682  	c.parent = parent
  8683  	return c
  8684  }
  8685  
  8686  // Filter sets the optional parameter "filter": The filter expression. The
  8687  // filter should have one of the following formats: "sn=123454" or
  8688  // "display_name=MyDevice". sn corresponds to serial number of the device. The
  8689  // filter is case insensitive.
  8690  func (c *NodesDevicesListCall) Filter(filter string) *NodesDevicesListCall {
  8691  	c.urlParams_.Set("filter", filter)
  8692  	return c
  8693  }
  8694  
  8695  // PageSize sets the optional parameter "pageSize": The maximum number of
  8696  // devices to return in the response. If empty or zero, all devices will be
  8697  // listed. Must be in the range [0, 1000].
  8698  func (c *NodesDevicesListCall) PageSize(pageSize int64) *NodesDevicesListCall {
  8699  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  8700  	return c
  8701  }
  8702  
  8703  // PageToken sets the optional parameter "pageToken": A pagination token
  8704  // returned from a previous call to ListDevices that indicates where this
  8705  // listing should continue from.
  8706  func (c *NodesDevicesListCall) PageToken(pageToken string) *NodesDevicesListCall {
  8707  	c.urlParams_.Set("pageToken", pageToken)
  8708  	return c
  8709  }
  8710  
  8711  // Fields allows partial responses to be retrieved. See
  8712  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8713  // details.
  8714  func (c *NodesDevicesListCall) Fields(s ...googleapi.Field) *NodesDevicesListCall {
  8715  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8716  	return c
  8717  }
  8718  
  8719  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  8720  // object's ETag matches the given value. This is useful for getting updates
  8721  // only after the object has changed since the last request.
  8722  func (c *NodesDevicesListCall) IfNoneMatch(entityTag string) *NodesDevicesListCall {
  8723  	c.ifNoneMatch_ = entityTag
  8724  	return c
  8725  }
  8726  
  8727  // Context sets the context to be used in this call's Do method.
  8728  func (c *NodesDevicesListCall) Context(ctx context.Context) *NodesDevicesListCall {
  8729  	c.ctx_ = ctx
  8730  	return c
  8731  }
  8732  
  8733  // Header returns a http.Header that can be modified by the caller to add
  8734  // headers to the request.
  8735  func (c *NodesDevicesListCall) Header() http.Header {
  8736  	if c.header_ == nil {
  8737  		c.header_ = make(http.Header)
  8738  	}
  8739  	return c.header_
  8740  }
  8741  
  8742  func (c *NodesDevicesListCall) doRequest(alt string) (*http.Response, error) {
  8743  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  8744  	if c.ifNoneMatch_ != "" {
  8745  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  8746  	}
  8747  	var body io.Reader = nil
  8748  	c.urlParams_.Set("alt", alt)
  8749  	c.urlParams_.Set("prettyPrint", "false")
  8750  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
  8751  	urls += "?" + c.urlParams_.Encode()
  8752  	req, err := http.NewRequest("GET", urls, body)
  8753  	if err != nil {
  8754  		return nil, err
  8755  	}
  8756  	req.Header = reqHeaders
  8757  	googleapi.Expand(req.URL, map[string]string{
  8758  		"parent": c.parent,
  8759  	})
  8760  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8761  }
  8762  
  8763  // Do executes the "sasportal.nodes.devices.list" call.
  8764  // Any non-2xx status code is an error. Response headers are in either
  8765  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
  8766  // returned at all) in error.(*googleapi.Error).Header. Use
  8767  // googleapi.IsNotModified to check whether the returned error was because
  8768  // http.StatusNotModified was returned.
  8769  func (c *NodesDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
  8770  	gensupport.SetOptions(c.urlParams_, opts...)
  8771  	res, err := c.doRequest("json")
  8772  	if res != nil && res.StatusCode == http.StatusNotModified {
  8773  		if res.Body != nil {
  8774  			res.Body.Close()
  8775  		}
  8776  		return nil, gensupport.WrapError(&googleapi.Error{
  8777  			Code:   res.StatusCode,
  8778  			Header: res.Header,
  8779  		})
  8780  	}
  8781  	if err != nil {
  8782  		return nil, err
  8783  	}
  8784  	defer googleapi.CloseBody(res)
  8785  	if err := googleapi.CheckResponse(res); err != nil {
  8786  		return nil, gensupport.WrapError(err)
  8787  	}
  8788  	ret := &SasPortalListDevicesResponse{
  8789  		ServerResponse: googleapi.ServerResponse{
  8790  			Header:         res.Header,
  8791  			HTTPStatusCode: res.StatusCode,
  8792  		},
  8793  	}
  8794  	target := &ret
  8795  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8796  		return nil, err
  8797  	}
  8798  	return ret, nil
  8799  }
  8800  
  8801  // Pages invokes f for each page of results.
  8802  // A non-nil error returned from f will halt the iteration.
  8803  // The provided context supersedes any context provided to the Context method.
  8804  func (c *NodesDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
  8805  	c.ctx_ = ctx
  8806  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  8807  	for {
  8808  		x, err := c.Do()
  8809  		if err != nil {
  8810  			return err
  8811  		}
  8812  		if err := f(x); err != nil {
  8813  			return err
  8814  		}
  8815  		if x.NextPageToken == "" {
  8816  			return nil
  8817  		}
  8818  		c.PageToken(x.NextPageToken)
  8819  	}
  8820  }
  8821  
  8822  type NodesDevicesMoveCall struct {
  8823  	s                          *Service
  8824  	name                       string
  8825  	sasportalmovedevicerequest *SasPortalMoveDeviceRequest
  8826  	urlParams_                 gensupport.URLParams
  8827  	ctx_                       context.Context
  8828  	header_                    http.Header
  8829  }
  8830  
  8831  // Move: Moves a device under another node or customer.
  8832  //
  8833  // - name: The name of the device to move.
  8834  func (r *NodesDevicesService) Move(name string, sasportalmovedevicerequest *SasPortalMoveDeviceRequest) *NodesDevicesMoveCall {
  8835  	c := &NodesDevicesMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8836  	c.name = name
  8837  	c.sasportalmovedevicerequest = sasportalmovedevicerequest
  8838  	return c
  8839  }
  8840  
  8841  // Fields allows partial responses to be retrieved. See
  8842  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8843  // details.
  8844  func (c *NodesDevicesMoveCall) Fields(s ...googleapi.Field) *NodesDevicesMoveCall {
  8845  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8846  	return c
  8847  }
  8848  
  8849  // Context sets the context to be used in this call's Do method.
  8850  func (c *NodesDevicesMoveCall) Context(ctx context.Context) *NodesDevicesMoveCall {
  8851  	c.ctx_ = ctx
  8852  	return c
  8853  }
  8854  
  8855  // Header returns a http.Header that can be modified by the caller to add
  8856  // headers to the request.
  8857  func (c *NodesDevicesMoveCall) Header() http.Header {
  8858  	if c.header_ == nil {
  8859  		c.header_ = make(http.Header)
  8860  	}
  8861  	return c.header_
  8862  }
  8863  
  8864  func (c *NodesDevicesMoveCall) doRequest(alt string) (*http.Response, error) {
  8865  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  8866  	var body io.Reader = nil
  8867  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovedevicerequest)
  8868  	if err != nil {
  8869  		return nil, err
  8870  	}
  8871  	c.urlParams_.Set("alt", alt)
  8872  	c.urlParams_.Set("prettyPrint", "false")
  8873  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  8874  	urls += "?" + c.urlParams_.Encode()
  8875  	req, err := http.NewRequest("POST", urls, body)
  8876  	if err != nil {
  8877  		return nil, err
  8878  	}
  8879  	req.Header = reqHeaders
  8880  	googleapi.Expand(req.URL, map[string]string{
  8881  		"name": c.name,
  8882  	})
  8883  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8884  }
  8885  
  8886  // Do executes the "sasportal.nodes.devices.move" call.
  8887  // Any non-2xx status code is an error. Response headers are in either
  8888  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  8889  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8890  // check whether the returned error was because http.StatusNotModified was
  8891  // returned.
  8892  func (c *NodesDevicesMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  8893  	gensupport.SetOptions(c.urlParams_, opts...)
  8894  	res, err := c.doRequest("json")
  8895  	if res != nil && res.StatusCode == http.StatusNotModified {
  8896  		if res.Body != nil {
  8897  			res.Body.Close()
  8898  		}
  8899  		return nil, gensupport.WrapError(&googleapi.Error{
  8900  			Code:   res.StatusCode,
  8901  			Header: res.Header,
  8902  		})
  8903  	}
  8904  	if err != nil {
  8905  		return nil, err
  8906  	}
  8907  	defer googleapi.CloseBody(res)
  8908  	if err := googleapi.CheckResponse(res); err != nil {
  8909  		return nil, gensupport.WrapError(err)
  8910  	}
  8911  	ret := &SasPortalOperation{
  8912  		ServerResponse: googleapi.ServerResponse{
  8913  			Header:         res.Header,
  8914  			HTTPStatusCode: res.StatusCode,
  8915  		},
  8916  	}
  8917  	target := &ret
  8918  	if err := gensupport.DecodeResponse(target, res); err != nil {
  8919  		return nil, err
  8920  	}
  8921  	return ret, nil
  8922  }
  8923  
  8924  type NodesDevicesPatchCall struct {
  8925  	s               *Service
  8926  	name            string
  8927  	sasportaldevice *SasPortalDevice
  8928  	urlParams_      gensupport.URLParams
  8929  	ctx_            context.Context
  8930  	header_         http.Header
  8931  }
  8932  
  8933  // Patch: Updates a device.
  8934  //
  8935  // - name: Output only. The resource path name.
  8936  func (r *NodesDevicesService) Patch(name string, sasportaldevice *SasPortalDevice) *NodesDevicesPatchCall {
  8937  	c := &NodesDevicesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  8938  	c.name = name
  8939  	c.sasportaldevice = sasportaldevice
  8940  	return c
  8941  }
  8942  
  8943  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  8944  func (c *NodesDevicesPatchCall) UpdateMask(updateMask string) *NodesDevicesPatchCall {
  8945  	c.urlParams_.Set("updateMask", updateMask)
  8946  	return c
  8947  }
  8948  
  8949  // Fields allows partial responses to be retrieved. See
  8950  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  8951  // details.
  8952  func (c *NodesDevicesPatchCall) Fields(s ...googleapi.Field) *NodesDevicesPatchCall {
  8953  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  8954  	return c
  8955  }
  8956  
  8957  // Context sets the context to be used in this call's Do method.
  8958  func (c *NodesDevicesPatchCall) Context(ctx context.Context) *NodesDevicesPatchCall {
  8959  	c.ctx_ = ctx
  8960  	return c
  8961  }
  8962  
  8963  // Header returns a http.Header that can be modified by the caller to add
  8964  // headers to the request.
  8965  func (c *NodesDevicesPatchCall) Header() http.Header {
  8966  	if c.header_ == nil {
  8967  		c.header_ = make(http.Header)
  8968  	}
  8969  	return c.header_
  8970  }
  8971  
  8972  func (c *NodesDevicesPatchCall) doRequest(alt string) (*http.Response, error) {
  8973  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  8974  	var body io.Reader = nil
  8975  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
  8976  	if err != nil {
  8977  		return nil, err
  8978  	}
  8979  	c.urlParams_.Set("alt", alt)
  8980  	c.urlParams_.Set("prettyPrint", "false")
  8981  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  8982  	urls += "?" + c.urlParams_.Encode()
  8983  	req, err := http.NewRequest("PATCH", urls, body)
  8984  	if err != nil {
  8985  		return nil, err
  8986  	}
  8987  	req.Header = reqHeaders
  8988  	googleapi.Expand(req.URL, map[string]string{
  8989  		"name": c.name,
  8990  	})
  8991  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  8992  }
  8993  
  8994  // Do executes the "sasportal.nodes.devices.patch" call.
  8995  // Any non-2xx status code is an error. Response headers are in either
  8996  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  8997  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  8998  // check whether the returned error was because http.StatusNotModified was
  8999  // returned.
  9000  func (c *NodesDevicesPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  9001  	gensupport.SetOptions(c.urlParams_, opts...)
  9002  	res, err := c.doRequest("json")
  9003  	if res != nil && res.StatusCode == http.StatusNotModified {
  9004  		if res.Body != nil {
  9005  			res.Body.Close()
  9006  		}
  9007  		return nil, gensupport.WrapError(&googleapi.Error{
  9008  			Code:   res.StatusCode,
  9009  			Header: res.Header,
  9010  		})
  9011  	}
  9012  	if err != nil {
  9013  		return nil, err
  9014  	}
  9015  	defer googleapi.CloseBody(res)
  9016  	if err := googleapi.CheckResponse(res); err != nil {
  9017  		return nil, gensupport.WrapError(err)
  9018  	}
  9019  	ret := &SasPortalDevice{
  9020  		ServerResponse: googleapi.ServerResponse{
  9021  			Header:         res.Header,
  9022  			HTTPStatusCode: res.StatusCode,
  9023  		},
  9024  	}
  9025  	target := &ret
  9026  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9027  		return nil, err
  9028  	}
  9029  	return ret, nil
  9030  }
  9031  
  9032  type NodesDevicesSignDeviceCall struct {
  9033  	s                          *Service
  9034  	name                       string
  9035  	sasportalsigndevicerequest *SasPortalSignDeviceRequest
  9036  	urlParams_                 gensupport.URLParams
  9037  	ctx_                       context.Context
  9038  	header_                    http.Header
  9039  }
  9040  
  9041  // SignDevice: Signs a device.
  9042  //
  9043  // - name: Output only. The resource path name.
  9044  func (r *NodesDevicesService) SignDevice(name string, sasportalsigndevicerequest *SasPortalSignDeviceRequest) *NodesDevicesSignDeviceCall {
  9045  	c := &NodesDevicesSignDeviceCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9046  	c.name = name
  9047  	c.sasportalsigndevicerequest = sasportalsigndevicerequest
  9048  	return c
  9049  }
  9050  
  9051  // Fields allows partial responses to be retrieved. See
  9052  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9053  // details.
  9054  func (c *NodesDevicesSignDeviceCall) Fields(s ...googleapi.Field) *NodesDevicesSignDeviceCall {
  9055  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9056  	return c
  9057  }
  9058  
  9059  // Context sets the context to be used in this call's Do method.
  9060  func (c *NodesDevicesSignDeviceCall) Context(ctx context.Context) *NodesDevicesSignDeviceCall {
  9061  	c.ctx_ = ctx
  9062  	return c
  9063  }
  9064  
  9065  // Header returns a http.Header that can be modified by the caller to add
  9066  // headers to the request.
  9067  func (c *NodesDevicesSignDeviceCall) Header() http.Header {
  9068  	if c.header_ == nil {
  9069  		c.header_ = make(http.Header)
  9070  	}
  9071  	return c.header_
  9072  }
  9073  
  9074  func (c *NodesDevicesSignDeviceCall) doRequest(alt string) (*http.Response, error) {
  9075  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9076  	var body io.Reader = nil
  9077  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalsigndevicerequest)
  9078  	if err != nil {
  9079  		return nil, err
  9080  	}
  9081  	c.urlParams_.Set("alt", alt)
  9082  	c.urlParams_.Set("prettyPrint", "false")
  9083  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:signDevice")
  9084  	urls += "?" + c.urlParams_.Encode()
  9085  	req, err := http.NewRequest("POST", urls, body)
  9086  	if err != nil {
  9087  		return nil, err
  9088  	}
  9089  	req.Header = reqHeaders
  9090  	googleapi.Expand(req.URL, map[string]string{
  9091  		"name": c.name,
  9092  	})
  9093  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9094  }
  9095  
  9096  // Do executes the "sasportal.nodes.devices.signDevice" call.
  9097  // Any non-2xx status code is an error. Response headers are in either
  9098  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  9099  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  9100  // whether the returned error was because http.StatusNotModified was returned.
  9101  func (c *NodesDevicesSignDeviceCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  9102  	gensupport.SetOptions(c.urlParams_, opts...)
  9103  	res, err := c.doRequest("json")
  9104  	if res != nil && res.StatusCode == http.StatusNotModified {
  9105  		if res.Body != nil {
  9106  			res.Body.Close()
  9107  		}
  9108  		return nil, gensupport.WrapError(&googleapi.Error{
  9109  			Code:   res.StatusCode,
  9110  			Header: res.Header,
  9111  		})
  9112  	}
  9113  	if err != nil {
  9114  		return nil, err
  9115  	}
  9116  	defer googleapi.CloseBody(res)
  9117  	if err := googleapi.CheckResponse(res); err != nil {
  9118  		return nil, gensupport.WrapError(err)
  9119  	}
  9120  	ret := &SasPortalEmpty{
  9121  		ServerResponse: googleapi.ServerResponse{
  9122  			Header:         res.Header,
  9123  			HTTPStatusCode: res.StatusCode,
  9124  		},
  9125  	}
  9126  	target := &ret
  9127  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9128  		return nil, err
  9129  	}
  9130  	return ret, nil
  9131  }
  9132  
  9133  type NodesDevicesUpdateSignedCall struct {
  9134  	s                                  *Service
  9135  	name                               string
  9136  	sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest
  9137  	urlParams_                         gensupport.URLParams
  9138  	ctx_                               context.Context
  9139  	header_                            http.Header
  9140  }
  9141  
  9142  // UpdateSigned: Updates a signed device.
  9143  //
  9144  // - name: The name of the device to update.
  9145  func (r *NodesDevicesService) UpdateSigned(name string, sasportalupdatesigneddevicerequest *SasPortalUpdateSignedDeviceRequest) *NodesDevicesUpdateSignedCall {
  9146  	c := &NodesDevicesUpdateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9147  	c.name = name
  9148  	c.sasportalupdatesigneddevicerequest = sasportalupdatesigneddevicerequest
  9149  	return c
  9150  }
  9151  
  9152  // Fields allows partial responses to be retrieved. See
  9153  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9154  // details.
  9155  func (c *NodesDevicesUpdateSignedCall) Fields(s ...googleapi.Field) *NodesDevicesUpdateSignedCall {
  9156  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9157  	return c
  9158  }
  9159  
  9160  // Context sets the context to be used in this call's Do method.
  9161  func (c *NodesDevicesUpdateSignedCall) Context(ctx context.Context) *NodesDevicesUpdateSignedCall {
  9162  	c.ctx_ = ctx
  9163  	return c
  9164  }
  9165  
  9166  // Header returns a http.Header that can be modified by the caller to add
  9167  // headers to the request.
  9168  func (c *NodesDevicesUpdateSignedCall) Header() http.Header {
  9169  	if c.header_ == nil {
  9170  		c.header_ = make(http.Header)
  9171  	}
  9172  	return c.header_
  9173  }
  9174  
  9175  func (c *NodesDevicesUpdateSignedCall) doRequest(alt string) (*http.Response, error) {
  9176  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9177  	var body io.Reader = nil
  9178  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalupdatesigneddevicerequest)
  9179  	if err != nil {
  9180  		return nil, err
  9181  	}
  9182  	c.urlParams_.Set("alt", alt)
  9183  	c.urlParams_.Set("prettyPrint", "false")
  9184  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:updateSigned")
  9185  	urls += "?" + c.urlParams_.Encode()
  9186  	req, err := http.NewRequest("PATCH", urls, body)
  9187  	if err != nil {
  9188  		return nil, err
  9189  	}
  9190  	req.Header = reqHeaders
  9191  	googleapi.Expand(req.URL, map[string]string{
  9192  		"name": c.name,
  9193  	})
  9194  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9195  }
  9196  
  9197  // Do executes the "sasportal.nodes.devices.updateSigned" call.
  9198  // Any non-2xx status code is an error. Response headers are in either
  9199  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
  9200  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  9201  // check whether the returned error was because http.StatusNotModified was
  9202  // returned.
  9203  func (c *NodesDevicesUpdateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
  9204  	gensupport.SetOptions(c.urlParams_, opts...)
  9205  	res, err := c.doRequest("json")
  9206  	if res != nil && res.StatusCode == http.StatusNotModified {
  9207  		if res.Body != nil {
  9208  			res.Body.Close()
  9209  		}
  9210  		return nil, gensupport.WrapError(&googleapi.Error{
  9211  			Code:   res.StatusCode,
  9212  			Header: res.Header,
  9213  		})
  9214  	}
  9215  	if err != nil {
  9216  		return nil, err
  9217  	}
  9218  	defer googleapi.CloseBody(res)
  9219  	if err := googleapi.CheckResponse(res); err != nil {
  9220  		return nil, gensupport.WrapError(err)
  9221  	}
  9222  	ret := &SasPortalDevice{
  9223  		ServerResponse: googleapi.ServerResponse{
  9224  			Header:         res.Header,
  9225  			HTTPStatusCode: res.StatusCode,
  9226  		},
  9227  	}
  9228  	target := &ret
  9229  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9230  		return nil, err
  9231  	}
  9232  	return ret, nil
  9233  }
  9234  
  9235  type NodesNodesCreateCall struct {
  9236  	s             *Service
  9237  	parent        string
  9238  	sasportalnode *SasPortalNode
  9239  	urlParams_    gensupport.URLParams
  9240  	ctx_          context.Context
  9241  	header_       http.Header
  9242  }
  9243  
  9244  // Create: Creates a new node.
  9245  //
  9246  // - parent: The parent resource name where the node is to be created.
  9247  func (r *NodesNodesService) Create(parent string, sasportalnode *SasPortalNode) *NodesNodesCreateCall {
  9248  	c := &NodesNodesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9249  	c.parent = parent
  9250  	c.sasportalnode = sasportalnode
  9251  	return c
  9252  }
  9253  
  9254  // Fields allows partial responses to be retrieved. See
  9255  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9256  // details.
  9257  func (c *NodesNodesCreateCall) Fields(s ...googleapi.Field) *NodesNodesCreateCall {
  9258  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9259  	return c
  9260  }
  9261  
  9262  // Context sets the context to be used in this call's Do method.
  9263  func (c *NodesNodesCreateCall) Context(ctx context.Context) *NodesNodesCreateCall {
  9264  	c.ctx_ = ctx
  9265  	return c
  9266  }
  9267  
  9268  // Header returns a http.Header that can be modified by the caller to add
  9269  // headers to the request.
  9270  func (c *NodesNodesCreateCall) Header() http.Header {
  9271  	if c.header_ == nil {
  9272  		c.header_ = make(http.Header)
  9273  	}
  9274  	return c.header_
  9275  }
  9276  
  9277  func (c *NodesNodesCreateCall) doRequest(alt string) (*http.Response, error) {
  9278  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9279  	var body io.Reader = nil
  9280  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
  9281  	if err != nil {
  9282  		return nil, err
  9283  	}
  9284  	c.urlParams_.Set("alt", alt)
  9285  	c.urlParams_.Set("prettyPrint", "false")
  9286  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  9287  	urls += "?" + c.urlParams_.Encode()
  9288  	req, err := http.NewRequest("POST", urls, body)
  9289  	if err != nil {
  9290  		return nil, err
  9291  	}
  9292  	req.Header = reqHeaders
  9293  	googleapi.Expand(req.URL, map[string]string{
  9294  		"parent": c.parent,
  9295  	})
  9296  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9297  }
  9298  
  9299  // Do executes the "sasportal.nodes.nodes.create" call.
  9300  // Any non-2xx status code is an error. Response headers are in either
  9301  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  9302  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  9303  // whether the returned error was because http.StatusNotModified was returned.
  9304  func (c *NodesNodesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  9305  	gensupport.SetOptions(c.urlParams_, opts...)
  9306  	res, err := c.doRequest("json")
  9307  	if res != nil && res.StatusCode == http.StatusNotModified {
  9308  		if res.Body != nil {
  9309  			res.Body.Close()
  9310  		}
  9311  		return nil, gensupport.WrapError(&googleapi.Error{
  9312  			Code:   res.StatusCode,
  9313  			Header: res.Header,
  9314  		})
  9315  	}
  9316  	if err != nil {
  9317  		return nil, err
  9318  	}
  9319  	defer googleapi.CloseBody(res)
  9320  	if err := googleapi.CheckResponse(res); err != nil {
  9321  		return nil, gensupport.WrapError(err)
  9322  	}
  9323  	ret := &SasPortalNode{
  9324  		ServerResponse: googleapi.ServerResponse{
  9325  			Header:         res.Header,
  9326  			HTTPStatusCode: res.StatusCode,
  9327  		},
  9328  	}
  9329  	target := &ret
  9330  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9331  		return nil, err
  9332  	}
  9333  	return ret, nil
  9334  }
  9335  
  9336  type NodesNodesDeleteCall struct {
  9337  	s          *Service
  9338  	name       string
  9339  	urlParams_ gensupport.URLParams
  9340  	ctx_       context.Context
  9341  	header_    http.Header
  9342  }
  9343  
  9344  // Delete: Deletes a node.
  9345  //
  9346  // - name: The name of the node.
  9347  func (r *NodesNodesService) Delete(name string) *NodesNodesDeleteCall {
  9348  	c := &NodesNodesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9349  	c.name = name
  9350  	return c
  9351  }
  9352  
  9353  // Fields allows partial responses to be retrieved. See
  9354  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9355  // details.
  9356  func (c *NodesNodesDeleteCall) Fields(s ...googleapi.Field) *NodesNodesDeleteCall {
  9357  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9358  	return c
  9359  }
  9360  
  9361  // Context sets the context to be used in this call's Do method.
  9362  func (c *NodesNodesDeleteCall) Context(ctx context.Context) *NodesNodesDeleteCall {
  9363  	c.ctx_ = ctx
  9364  	return c
  9365  }
  9366  
  9367  // Header returns a http.Header that can be modified by the caller to add
  9368  // headers to the request.
  9369  func (c *NodesNodesDeleteCall) Header() http.Header {
  9370  	if c.header_ == nil {
  9371  		c.header_ = make(http.Header)
  9372  	}
  9373  	return c.header_
  9374  }
  9375  
  9376  func (c *NodesNodesDeleteCall) doRequest(alt string) (*http.Response, error) {
  9377  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  9378  	var body io.Reader = nil
  9379  	c.urlParams_.Set("alt", alt)
  9380  	c.urlParams_.Set("prettyPrint", "false")
  9381  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  9382  	urls += "?" + c.urlParams_.Encode()
  9383  	req, err := http.NewRequest("DELETE", urls, body)
  9384  	if err != nil {
  9385  		return nil, err
  9386  	}
  9387  	req.Header = reqHeaders
  9388  	googleapi.Expand(req.URL, map[string]string{
  9389  		"name": c.name,
  9390  	})
  9391  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9392  }
  9393  
  9394  // Do executes the "sasportal.nodes.nodes.delete" call.
  9395  // Any non-2xx status code is an error. Response headers are in either
  9396  // *SasPortalEmpty.ServerResponse.Header or (if a response was returned at all)
  9397  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  9398  // whether the returned error was because http.StatusNotModified was returned.
  9399  func (c *NodesNodesDeleteCall) Do(opts ...googleapi.CallOption) (*SasPortalEmpty, error) {
  9400  	gensupport.SetOptions(c.urlParams_, opts...)
  9401  	res, err := c.doRequest("json")
  9402  	if res != nil && res.StatusCode == http.StatusNotModified {
  9403  		if res.Body != nil {
  9404  			res.Body.Close()
  9405  		}
  9406  		return nil, gensupport.WrapError(&googleapi.Error{
  9407  			Code:   res.StatusCode,
  9408  			Header: res.Header,
  9409  		})
  9410  	}
  9411  	if err != nil {
  9412  		return nil, err
  9413  	}
  9414  	defer googleapi.CloseBody(res)
  9415  	if err := googleapi.CheckResponse(res); err != nil {
  9416  		return nil, gensupport.WrapError(err)
  9417  	}
  9418  	ret := &SasPortalEmpty{
  9419  		ServerResponse: googleapi.ServerResponse{
  9420  			Header:         res.Header,
  9421  			HTTPStatusCode: res.StatusCode,
  9422  		},
  9423  	}
  9424  	target := &ret
  9425  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9426  		return nil, err
  9427  	}
  9428  	return ret, nil
  9429  }
  9430  
  9431  type NodesNodesGetCall struct {
  9432  	s            *Service
  9433  	name         string
  9434  	urlParams_   gensupport.URLParams
  9435  	ifNoneMatch_ string
  9436  	ctx_         context.Context
  9437  	header_      http.Header
  9438  }
  9439  
  9440  // Get: Returns a requested node.
  9441  //
  9442  // - name: The name of the node.
  9443  func (r *NodesNodesService) Get(name string) *NodesNodesGetCall {
  9444  	c := &NodesNodesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9445  	c.name = name
  9446  	return c
  9447  }
  9448  
  9449  // Fields allows partial responses to be retrieved. See
  9450  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9451  // details.
  9452  func (c *NodesNodesGetCall) Fields(s ...googleapi.Field) *NodesNodesGetCall {
  9453  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9454  	return c
  9455  }
  9456  
  9457  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  9458  // object's ETag matches the given value. This is useful for getting updates
  9459  // only after the object has changed since the last request.
  9460  func (c *NodesNodesGetCall) IfNoneMatch(entityTag string) *NodesNodesGetCall {
  9461  	c.ifNoneMatch_ = entityTag
  9462  	return c
  9463  }
  9464  
  9465  // Context sets the context to be used in this call's Do method.
  9466  func (c *NodesNodesGetCall) Context(ctx context.Context) *NodesNodesGetCall {
  9467  	c.ctx_ = ctx
  9468  	return c
  9469  }
  9470  
  9471  // Header returns a http.Header that can be modified by the caller to add
  9472  // headers to the request.
  9473  func (c *NodesNodesGetCall) Header() http.Header {
  9474  	if c.header_ == nil {
  9475  		c.header_ = make(http.Header)
  9476  	}
  9477  	return c.header_
  9478  }
  9479  
  9480  func (c *NodesNodesGetCall) doRequest(alt string) (*http.Response, error) {
  9481  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  9482  	if c.ifNoneMatch_ != "" {
  9483  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  9484  	}
  9485  	var body io.Reader = nil
  9486  	c.urlParams_.Set("alt", alt)
  9487  	c.urlParams_.Set("prettyPrint", "false")
  9488  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  9489  	urls += "?" + c.urlParams_.Encode()
  9490  	req, err := http.NewRequest("GET", urls, body)
  9491  	if err != nil {
  9492  		return nil, err
  9493  	}
  9494  	req.Header = reqHeaders
  9495  	googleapi.Expand(req.URL, map[string]string{
  9496  		"name": c.name,
  9497  	})
  9498  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9499  }
  9500  
  9501  // Do executes the "sasportal.nodes.nodes.get" call.
  9502  // Any non-2xx status code is an error. Response headers are in either
  9503  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  9504  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  9505  // whether the returned error was because http.StatusNotModified was returned.
  9506  func (c *NodesNodesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  9507  	gensupport.SetOptions(c.urlParams_, opts...)
  9508  	res, err := c.doRequest("json")
  9509  	if res != nil && res.StatusCode == http.StatusNotModified {
  9510  		if res.Body != nil {
  9511  			res.Body.Close()
  9512  		}
  9513  		return nil, gensupport.WrapError(&googleapi.Error{
  9514  			Code:   res.StatusCode,
  9515  			Header: res.Header,
  9516  		})
  9517  	}
  9518  	if err != nil {
  9519  		return nil, err
  9520  	}
  9521  	defer googleapi.CloseBody(res)
  9522  	if err := googleapi.CheckResponse(res); err != nil {
  9523  		return nil, gensupport.WrapError(err)
  9524  	}
  9525  	ret := &SasPortalNode{
  9526  		ServerResponse: googleapi.ServerResponse{
  9527  			Header:         res.Header,
  9528  			HTTPStatusCode: res.StatusCode,
  9529  		},
  9530  	}
  9531  	target := &ret
  9532  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9533  		return nil, err
  9534  	}
  9535  	return ret, nil
  9536  }
  9537  
  9538  type NodesNodesListCall struct {
  9539  	s            *Service
  9540  	parent       string
  9541  	urlParams_   gensupport.URLParams
  9542  	ifNoneMatch_ string
  9543  	ctx_         context.Context
  9544  	header_      http.Header
  9545  }
  9546  
  9547  // List: Lists nodes.
  9548  //
  9549  // - parent: The parent resource name, for example, "nodes/1".
  9550  func (r *NodesNodesService) List(parent string) *NodesNodesListCall {
  9551  	c := &NodesNodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9552  	c.parent = parent
  9553  	return c
  9554  }
  9555  
  9556  // Filter sets the optional parameter "filter": The filter expression. The
  9557  // filter should have the following format: "DIRECT_CHILDREN" or format:
  9558  // "direct_children". The filter is case insensitive. If empty, then no nodes
  9559  // are filtered.
  9560  func (c *NodesNodesListCall) Filter(filter string) *NodesNodesListCall {
  9561  	c.urlParams_.Set("filter", filter)
  9562  	return c
  9563  }
  9564  
  9565  // PageSize sets the optional parameter "pageSize": The maximum number of nodes
  9566  // to return in the response.
  9567  func (c *NodesNodesListCall) PageSize(pageSize int64) *NodesNodesListCall {
  9568  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  9569  	return c
  9570  }
  9571  
  9572  // PageToken sets the optional parameter "pageToken": A pagination token
  9573  // returned from a previous call to ListNodes that indicates where this listing
  9574  // should continue from.
  9575  func (c *NodesNodesListCall) PageToken(pageToken string) *NodesNodesListCall {
  9576  	c.urlParams_.Set("pageToken", pageToken)
  9577  	return c
  9578  }
  9579  
  9580  // Fields allows partial responses to be retrieved. See
  9581  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9582  // details.
  9583  func (c *NodesNodesListCall) Fields(s ...googleapi.Field) *NodesNodesListCall {
  9584  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9585  	return c
  9586  }
  9587  
  9588  // IfNoneMatch sets an optional parameter which makes the operation fail if the
  9589  // object's ETag matches the given value. This is useful for getting updates
  9590  // only after the object has changed since the last request.
  9591  func (c *NodesNodesListCall) IfNoneMatch(entityTag string) *NodesNodesListCall {
  9592  	c.ifNoneMatch_ = entityTag
  9593  	return c
  9594  }
  9595  
  9596  // Context sets the context to be used in this call's Do method.
  9597  func (c *NodesNodesListCall) Context(ctx context.Context) *NodesNodesListCall {
  9598  	c.ctx_ = ctx
  9599  	return c
  9600  }
  9601  
  9602  // Header returns a http.Header that can be modified by the caller to add
  9603  // headers to the request.
  9604  func (c *NodesNodesListCall) Header() http.Header {
  9605  	if c.header_ == nil {
  9606  		c.header_ = make(http.Header)
  9607  	}
  9608  	return c.header_
  9609  }
  9610  
  9611  func (c *NodesNodesListCall) doRequest(alt string) (*http.Response, error) {
  9612  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
  9613  	if c.ifNoneMatch_ != "" {
  9614  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  9615  	}
  9616  	var body io.Reader = nil
  9617  	c.urlParams_.Set("alt", alt)
  9618  	c.urlParams_.Set("prettyPrint", "false")
  9619  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
  9620  	urls += "?" + c.urlParams_.Encode()
  9621  	req, err := http.NewRequest("GET", urls, body)
  9622  	if err != nil {
  9623  		return nil, err
  9624  	}
  9625  	req.Header = reqHeaders
  9626  	googleapi.Expand(req.URL, map[string]string{
  9627  		"parent": c.parent,
  9628  	})
  9629  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9630  }
  9631  
  9632  // Do executes the "sasportal.nodes.nodes.list" call.
  9633  // Any non-2xx status code is an error. Response headers are in either
  9634  // *SasPortalListNodesResponse.ServerResponse.Header or (if a response was
  9635  // returned at all) in error.(*googleapi.Error).Header. Use
  9636  // googleapi.IsNotModified to check whether the returned error was because
  9637  // http.StatusNotModified was returned.
  9638  func (c *NodesNodesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListNodesResponse, error) {
  9639  	gensupport.SetOptions(c.urlParams_, opts...)
  9640  	res, err := c.doRequest("json")
  9641  	if res != nil && res.StatusCode == http.StatusNotModified {
  9642  		if res.Body != nil {
  9643  			res.Body.Close()
  9644  		}
  9645  		return nil, gensupport.WrapError(&googleapi.Error{
  9646  			Code:   res.StatusCode,
  9647  			Header: res.Header,
  9648  		})
  9649  	}
  9650  	if err != nil {
  9651  		return nil, err
  9652  	}
  9653  	defer googleapi.CloseBody(res)
  9654  	if err := googleapi.CheckResponse(res); err != nil {
  9655  		return nil, gensupport.WrapError(err)
  9656  	}
  9657  	ret := &SasPortalListNodesResponse{
  9658  		ServerResponse: googleapi.ServerResponse{
  9659  			Header:         res.Header,
  9660  			HTTPStatusCode: res.StatusCode,
  9661  		},
  9662  	}
  9663  	target := &ret
  9664  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9665  		return nil, err
  9666  	}
  9667  	return ret, nil
  9668  }
  9669  
  9670  // Pages invokes f for each page of results.
  9671  // A non-nil error returned from f will halt the iteration.
  9672  // The provided context supersedes any context provided to the Context method.
  9673  func (c *NodesNodesListCall) Pages(ctx context.Context, f func(*SasPortalListNodesResponse) error) error {
  9674  	c.ctx_ = ctx
  9675  	defer c.PageToken(c.urlParams_.Get("pageToken"))
  9676  	for {
  9677  		x, err := c.Do()
  9678  		if err != nil {
  9679  			return err
  9680  		}
  9681  		if err := f(x); err != nil {
  9682  			return err
  9683  		}
  9684  		if x.NextPageToken == "" {
  9685  			return nil
  9686  		}
  9687  		c.PageToken(x.NextPageToken)
  9688  	}
  9689  }
  9690  
  9691  type NodesNodesMoveCall struct {
  9692  	s                        *Service
  9693  	name                     string
  9694  	sasportalmovenoderequest *SasPortalMoveNodeRequest
  9695  	urlParams_               gensupport.URLParams
  9696  	ctx_                     context.Context
  9697  	header_                  http.Header
  9698  }
  9699  
  9700  // Move: Moves a node under another node or customer.
  9701  //
  9702  // - name: The name of the node to move.
  9703  func (r *NodesNodesService) Move(name string, sasportalmovenoderequest *SasPortalMoveNodeRequest) *NodesNodesMoveCall {
  9704  	c := &NodesNodesMoveCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9705  	c.name = name
  9706  	c.sasportalmovenoderequest = sasportalmovenoderequest
  9707  	return c
  9708  }
  9709  
  9710  // Fields allows partial responses to be retrieved. See
  9711  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9712  // details.
  9713  func (c *NodesNodesMoveCall) Fields(s ...googleapi.Field) *NodesNodesMoveCall {
  9714  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9715  	return c
  9716  }
  9717  
  9718  // Context sets the context to be used in this call's Do method.
  9719  func (c *NodesNodesMoveCall) Context(ctx context.Context) *NodesNodesMoveCall {
  9720  	c.ctx_ = ctx
  9721  	return c
  9722  }
  9723  
  9724  // Header returns a http.Header that can be modified by the caller to add
  9725  // headers to the request.
  9726  func (c *NodesNodesMoveCall) Header() http.Header {
  9727  	if c.header_ == nil {
  9728  		c.header_ = make(http.Header)
  9729  	}
  9730  	return c.header_
  9731  }
  9732  
  9733  func (c *NodesNodesMoveCall) doRequest(alt string) (*http.Response, error) {
  9734  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9735  	var body io.Reader = nil
  9736  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalmovenoderequest)
  9737  	if err != nil {
  9738  		return nil, err
  9739  	}
  9740  	c.urlParams_.Set("alt", alt)
  9741  	c.urlParams_.Set("prettyPrint", "false")
  9742  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}:move")
  9743  	urls += "?" + c.urlParams_.Encode()
  9744  	req, err := http.NewRequest("POST", urls, body)
  9745  	if err != nil {
  9746  		return nil, err
  9747  	}
  9748  	req.Header = reqHeaders
  9749  	googleapi.Expand(req.URL, map[string]string{
  9750  		"name": c.name,
  9751  	})
  9752  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9753  }
  9754  
  9755  // Do executes the "sasportal.nodes.nodes.move" call.
  9756  // Any non-2xx status code is an error. Response headers are in either
  9757  // *SasPortalOperation.ServerResponse.Header or (if a response was returned at
  9758  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  9759  // check whether the returned error was because http.StatusNotModified was
  9760  // returned.
  9761  func (c *NodesNodesMoveCall) Do(opts ...googleapi.CallOption) (*SasPortalOperation, error) {
  9762  	gensupport.SetOptions(c.urlParams_, opts...)
  9763  	res, err := c.doRequest("json")
  9764  	if res != nil && res.StatusCode == http.StatusNotModified {
  9765  		if res.Body != nil {
  9766  			res.Body.Close()
  9767  		}
  9768  		return nil, gensupport.WrapError(&googleapi.Error{
  9769  			Code:   res.StatusCode,
  9770  			Header: res.Header,
  9771  		})
  9772  	}
  9773  	if err != nil {
  9774  		return nil, err
  9775  	}
  9776  	defer googleapi.CloseBody(res)
  9777  	if err := googleapi.CheckResponse(res); err != nil {
  9778  		return nil, gensupport.WrapError(err)
  9779  	}
  9780  	ret := &SasPortalOperation{
  9781  		ServerResponse: googleapi.ServerResponse{
  9782  			Header:         res.Header,
  9783  			HTTPStatusCode: res.StatusCode,
  9784  		},
  9785  	}
  9786  	target := &ret
  9787  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9788  		return nil, err
  9789  	}
  9790  	return ret, nil
  9791  }
  9792  
  9793  type NodesNodesPatchCall struct {
  9794  	s             *Service
  9795  	name          string
  9796  	sasportalnode *SasPortalNode
  9797  	urlParams_    gensupport.URLParams
  9798  	ctx_          context.Context
  9799  	header_       http.Header
  9800  }
  9801  
  9802  // Patch: Updates an existing node.
  9803  //
  9804  // - name: Output only. Resource name.
  9805  func (r *NodesNodesService) Patch(name string, sasportalnode *SasPortalNode) *NodesNodesPatchCall {
  9806  	c := &NodesNodesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9807  	c.name = name
  9808  	c.sasportalnode = sasportalnode
  9809  	return c
  9810  }
  9811  
  9812  // UpdateMask sets the optional parameter "updateMask": Fields to be updated.
  9813  func (c *NodesNodesPatchCall) UpdateMask(updateMask string) *NodesNodesPatchCall {
  9814  	c.urlParams_.Set("updateMask", updateMask)
  9815  	return c
  9816  }
  9817  
  9818  // Fields allows partial responses to be retrieved. See
  9819  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9820  // details.
  9821  func (c *NodesNodesPatchCall) Fields(s ...googleapi.Field) *NodesNodesPatchCall {
  9822  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9823  	return c
  9824  }
  9825  
  9826  // Context sets the context to be used in this call's Do method.
  9827  func (c *NodesNodesPatchCall) Context(ctx context.Context) *NodesNodesPatchCall {
  9828  	c.ctx_ = ctx
  9829  	return c
  9830  }
  9831  
  9832  // Header returns a http.Header that can be modified by the caller to add
  9833  // headers to the request.
  9834  func (c *NodesNodesPatchCall) Header() http.Header {
  9835  	if c.header_ == nil {
  9836  		c.header_ = make(http.Header)
  9837  	}
  9838  	return c.header_
  9839  }
  9840  
  9841  func (c *NodesNodesPatchCall) doRequest(alt string) (*http.Response, error) {
  9842  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9843  	var body io.Reader = nil
  9844  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
  9845  	if err != nil {
  9846  		return nil, err
  9847  	}
  9848  	c.urlParams_.Set("alt", alt)
  9849  	c.urlParams_.Set("prettyPrint", "false")
  9850  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+name}")
  9851  	urls += "?" + c.urlParams_.Encode()
  9852  	req, err := http.NewRequest("PATCH", urls, body)
  9853  	if err != nil {
  9854  		return nil, err
  9855  	}
  9856  	req.Header = reqHeaders
  9857  	googleapi.Expand(req.URL, map[string]string{
  9858  		"name": c.name,
  9859  	})
  9860  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9861  }
  9862  
  9863  // Do executes the "sasportal.nodes.nodes.patch" call.
  9864  // Any non-2xx status code is an error. Response headers are in either
  9865  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
  9866  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
  9867  // whether the returned error was because http.StatusNotModified was returned.
  9868  func (c *NodesNodesPatchCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
  9869  	gensupport.SetOptions(c.urlParams_, opts...)
  9870  	res, err := c.doRequest("json")
  9871  	if res != nil && res.StatusCode == http.StatusNotModified {
  9872  		if res.Body != nil {
  9873  			res.Body.Close()
  9874  		}
  9875  		return nil, gensupport.WrapError(&googleapi.Error{
  9876  			Code:   res.StatusCode,
  9877  			Header: res.Header,
  9878  		})
  9879  	}
  9880  	if err != nil {
  9881  		return nil, err
  9882  	}
  9883  	defer googleapi.CloseBody(res)
  9884  	if err := googleapi.CheckResponse(res); err != nil {
  9885  		return nil, gensupport.WrapError(err)
  9886  	}
  9887  	ret := &SasPortalNode{
  9888  		ServerResponse: googleapi.ServerResponse{
  9889  			Header:         res.Header,
  9890  			HTTPStatusCode: res.StatusCode,
  9891  		},
  9892  	}
  9893  	target := &ret
  9894  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9895  		return nil, err
  9896  	}
  9897  	return ret, nil
  9898  }
  9899  
  9900  type NodesNodesDeploymentsCreateCall struct {
  9901  	s                   *Service
  9902  	parent              string
  9903  	sasportaldeployment *SasPortalDeployment
  9904  	urlParams_          gensupport.URLParams
  9905  	ctx_                context.Context
  9906  	header_             http.Header
  9907  }
  9908  
  9909  // Create: Creates a new deployment.
  9910  //
  9911  // - parent: The parent resource name where the deployment is to be created.
  9912  func (r *NodesNodesDeploymentsService) Create(parent string, sasportaldeployment *SasPortalDeployment) *NodesNodesDeploymentsCreateCall {
  9913  	c := &NodesNodesDeploymentsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  9914  	c.parent = parent
  9915  	c.sasportaldeployment = sasportaldeployment
  9916  	return c
  9917  }
  9918  
  9919  // Fields allows partial responses to be retrieved. See
  9920  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
  9921  // details.
  9922  func (c *NodesNodesDeploymentsCreateCall) Fields(s ...googleapi.Field) *NodesNodesDeploymentsCreateCall {
  9923  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  9924  	return c
  9925  }
  9926  
  9927  // Context sets the context to be used in this call's Do method.
  9928  func (c *NodesNodesDeploymentsCreateCall) Context(ctx context.Context) *NodesNodesDeploymentsCreateCall {
  9929  	c.ctx_ = ctx
  9930  	return c
  9931  }
  9932  
  9933  // Header returns a http.Header that can be modified by the caller to add
  9934  // headers to the request.
  9935  func (c *NodesNodesDeploymentsCreateCall) Header() http.Header {
  9936  	if c.header_ == nil {
  9937  		c.header_ = make(http.Header)
  9938  	}
  9939  	return c.header_
  9940  }
  9941  
  9942  func (c *NodesNodesDeploymentsCreateCall) doRequest(alt string) (*http.Response, error) {
  9943  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
  9944  	var body io.Reader = nil
  9945  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldeployment)
  9946  	if err != nil {
  9947  		return nil, err
  9948  	}
  9949  	c.urlParams_.Set("alt", alt)
  9950  	c.urlParams_.Set("prettyPrint", "false")
  9951  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
  9952  	urls += "?" + c.urlParams_.Encode()
  9953  	req, err := http.NewRequest("POST", urls, body)
  9954  	if err != nil {
  9955  		return nil, err
  9956  	}
  9957  	req.Header = reqHeaders
  9958  	googleapi.Expand(req.URL, map[string]string{
  9959  		"parent": c.parent,
  9960  	})
  9961  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  9962  }
  9963  
  9964  // Do executes the "sasportal.nodes.nodes.deployments.create" call.
  9965  // Any non-2xx status code is an error. Response headers are in either
  9966  // *SasPortalDeployment.ServerResponse.Header or (if a response was returned at
  9967  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  9968  // check whether the returned error was because http.StatusNotModified was
  9969  // returned.
  9970  func (c *NodesNodesDeploymentsCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDeployment, error) {
  9971  	gensupport.SetOptions(c.urlParams_, opts...)
  9972  	res, err := c.doRequest("json")
  9973  	if res != nil && res.StatusCode == http.StatusNotModified {
  9974  		if res.Body != nil {
  9975  			res.Body.Close()
  9976  		}
  9977  		return nil, gensupport.WrapError(&googleapi.Error{
  9978  			Code:   res.StatusCode,
  9979  			Header: res.Header,
  9980  		})
  9981  	}
  9982  	if err != nil {
  9983  		return nil, err
  9984  	}
  9985  	defer googleapi.CloseBody(res)
  9986  	if err := googleapi.CheckResponse(res); err != nil {
  9987  		return nil, gensupport.WrapError(err)
  9988  	}
  9989  	ret := &SasPortalDeployment{
  9990  		ServerResponse: googleapi.ServerResponse{
  9991  			Header:         res.Header,
  9992  			HTTPStatusCode: res.StatusCode,
  9993  		},
  9994  	}
  9995  	target := &ret
  9996  	if err := gensupport.DecodeResponse(target, res); err != nil {
  9997  		return nil, err
  9998  	}
  9999  	return ret, nil
 10000  }
 10001  
 10002  type NodesNodesDeploymentsListCall struct {
 10003  	s            *Service
 10004  	parent       string
 10005  	urlParams_   gensupport.URLParams
 10006  	ifNoneMatch_ string
 10007  	ctx_         context.Context
 10008  	header_      http.Header
 10009  }
 10010  
 10011  // List: Lists deployments.
 10012  //
 10013  //   - parent: The parent resource name, for example, "nodes/1",
 10014  //     customer/1/nodes/2.
 10015  func (r *NodesNodesDeploymentsService) List(parent string) *NodesNodesDeploymentsListCall {
 10016  	c := &NodesNodesDeploymentsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10017  	c.parent = parent
 10018  	return c
 10019  }
 10020  
 10021  // Filter sets the optional parameter "filter": The filter expression. The
 10022  // filter should have the following format: "DIRECT_CHILDREN" or format:
 10023  // "direct_children". The filter is case insensitive. If empty, then no
 10024  // deployments are filtered.
 10025  func (c *NodesNodesDeploymentsListCall) Filter(filter string) *NodesNodesDeploymentsListCall {
 10026  	c.urlParams_.Set("filter", filter)
 10027  	return c
 10028  }
 10029  
 10030  // PageSize sets the optional parameter "pageSize": The maximum number of
 10031  // deployments to return in the response.
 10032  func (c *NodesNodesDeploymentsListCall) PageSize(pageSize int64) *NodesNodesDeploymentsListCall {
 10033  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
 10034  	return c
 10035  }
 10036  
 10037  // PageToken sets the optional parameter "pageToken": A pagination token
 10038  // returned from a previous call to ListDeployments that indicates where this
 10039  // listing should continue from.
 10040  func (c *NodesNodesDeploymentsListCall) PageToken(pageToken string) *NodesNodesDeploymentsListCall {
 10041  	c.urlParams_.Set("pageToken", pageToken)
 10042  	return c
 10043  }
 10044  
 10045  // Fields allows partial responses to be retrieved. See
 10046  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10047  // details.
 10048  func (c *NodesNodesDeploymentsListCall) Fields(s ...googleapi.Field) *NodesNodesDeploymentsListCall {
 10049  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10050  	return c
 10051  }
 10052  
 10053  // IfNoneMatch sets an optional parameter which makes the operation fail if the
 10054  // object's ETag matches the given value. This is useful for getting updates
 10055  // only after the object has changed since the last request.
 10056  func (c *NodesNodesDeploymentsListCall) IfNoneMatch(entityTag string) *NodesNodesDeploymentsListCall {
 10057  	c.ifNoneMatch_ = entityTag
 10058  	return c
 10059  }
 10060  
 10061  // Context sets the context to be used in this call's Do method.
 10062  func (c *NodesNodesDeploymentsListCall) Context(ctx context.Context) *NodesNodesDeploymentsListCall {
 10063  	c.ctx_ = ctx
 10064  	return c
 10065  }
 10066  
 10067  // Header returns a http.Header that can be modified by the caller to add
 10068  // headers to the request.
 10069  func (c *NodesNodesDeploymentsListCall) Header() http.Header {
 10070  	if c.header_ == nil {
 10071  		c.header_ = make(http.Header)
 10072  	}
 10073  	return c.header_
 10074  }
 10075  
 10076  func (c *NodesNodesDeploymentsListCall) doRequest(alt string) (*http.Response, error) {
 10077  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
 10078  	if c.ifNoneMatch_ != "" {
 10079  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
 10080  	}
 10081  	var body io.Reader = nil
 10082  	c.urlParams_.Set("alt", alt)
 10083  	c.urlParams_.Set("prettyPrint", "false")
 10084  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/deployments")
 10085  	urls += "?" + c.urlParams_.Encode()
 10086  	req, err := http.NewRequest("GET", urls, body)
 10087  	if err != nil {
 10088  		return nil, err
 10089  	}
 10090  	req.Header = reqHeaders
 10091  	googleapi.Expand(req.URL, map[string]string{
 10092  		"parent": c.parent,
 10093  	})
 10094  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10095  }
 10096  
 10097  // Do executes the "sasportal.nodes.nodes.deployments.list" call.
 10098  // Any non-2xx status code is an error. Response headers are in either
 10099  // *SasPortalListDeploymentsResponse.ServerResponse.Header or (if a response
 10100  // was returned at all) in error.(*googleapi.Error).Header. Use
 10101  // googleapi.IsNotModified to check whether the returned error was because
 10102  // http.StatusNotModified was returned.
 10103  func (c *NodesNodesDeploymentsListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDeploymentsResponse, error) {
 10104  	gensupport.SetOptions(c.urlParams_, opts...)
 10105  	res, err := c.doRequest("json")
 10106  	if res != nil && res.StatusCode == http.StatusNotModified {
 10107  		if res.Body != nil {
 10108  			res.Body.Close()
 10109  		}
 10110  		return nil, gensupport.WrapError(&googleapi.Error{
 10111  			Code:   res.StatusCode,
 10112  			Header: res.Header,
 10113  		})
 10114  	}
 10115  	if err != nil {
 10116  		return nil, err
 10117  	}
 10118  	defer googleapi.CloseBody(res)
 10119  	if err := googleapi.CheckResponse(res); err != nil {
 10120  		return nil, gensupport.WrapError(err)
 10121  	}
 10122  	ret := &SasPortalListDeploymentsResponse{
 10123  		ServerResponse: googleapi.ServerResponse{
 10124  			Header:         res.Header,
 10125  			HTTPStatusCode: res.StatusCode,
 10126  		},
 10127  	}
 10128  	target := &ret
 10129  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10130  		return nil, err
 10131  	}
 10132  	return ret, nil
 10133  }
 10134  
 10135  // Pages invokes f for each page of results.
 10136  // A non-nil error returned from f will halt the iteration.
 10137  // The provided context supersedes any context provided to the Context method.
 10138  func (c *NodesNodesDeploymentsListCall) Pages(ctx context.Context, f func(*SasPortalListDeploymentsResponse) error) error {
 10139  	c.ctx_ = ctx
 10140  	defer c.PageToken(c.urlParams_.Get("pageToken"))
 10141  	for {
 10142  		x, err := c.Do()
 10143  		if err != nil {
 10144  			return err
 10145  		}
 10146  		if err := f(x); err != nil {
 10147  			return err
 10148  		}
 10149  		if x.NextPageToken == "" {
 10150  			return nil
 10151  		}
 10152  		c.PageToken(x.NextPageToken)
 10153  	}
 10154  }
 10155  
 10156  type NodesNodesDevicesCreateCall struct {
 10157  	s               *Service
 10158  	parent          string
 10159  	sasportaldevice *SasPortalDevice
 10160  	urlParams_      gensupport.URLParams
 10161  	ctx_            context.Context
 10162  	header_         http.Header
 10163  }
 10164  
 10165  // Create: Creates a device under a node or customer.
 10166  //
 10167  // - parent: The name of the parent resource.
 10168  func (r *NodesNodesDevicesService) Create(parent string, sasportaldevice *SasPortalDevice) *NodesNodesDevicesCreateCall {
 10169  	c := &NodesNodesDevicesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10170  	c.parent = parent
 10171  	c.sasportaldevice = sasportaldevice
 10172  	return c
 10173  }
 10174  
 10175  // Fields allows partial responses to be retrieved. See
 10176  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10177  // details.
 10178  func (c *NodesNodesDevicesCreateCall) Fields(s ...googleapi.Field) *NodesNodesDevicesCreateCall {
 10179  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10180  	return c
 10181  }
 10182  
 10183  // Context sets the context to be used in this call's Do method.
 10184  func (c *NodesNodesDevicesCreateCall) Context(ctx context.Context) *NodesNodesDevicesCreateCall {
 10185  	c.ctx_ = ctx
 10186  	return c
 10187  }
 10188  
 10189  // Header returns a http.Header that can be modified by the caller to add
 10190  // headers to the request.
 10191  func (c *NodesNodesDevicesCreateCall) Header() http.Header {
 10192  	if c.header_ == nil {
 10193  		c.header_ = make(http.Header)
 10194  	}
 10195  	return c.header_
 10196  }
 10197  
 10198  func (c *NodesNodesDevicesCreateCall) doRequest(alt string) (*http.Response, error) {
 10199  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 10200  	var body io.Reader = nil
 10201  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaldevice)
 10202  	if err != nil {
 10203  		return nil, err
 10204  	}
 10205  	c.urlParams_.Set("alt", alt)
 10206  	c.urlParams_.Set("prettyPrint", "false")
 10207  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
 10208  	urls += "?" + c.urlParams_.Encode()
 10209  	req, err := http.NewRequest("POST", urls, body)
 10210  	if err != nil {
 10211  		return nil, err
 10212  	}
 10213  	req.Header = reqHeaders
 10214  	googleapi.Expand(req.URL, map[string]string{
 10215  		"parent": c.parent,
 10216  	})
 10217  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10218  }
 10219  
 10220  // Do executes the "sasportal.nodes.nodes.devices.create" call.
 10221  // Any non-2xx status code is an error. Response headers are in either
 10222  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
 10223  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
 10224  // check whether the returned error was because http.StatusNotModified was
 10225  // returned.
 10226  func (c *NodesNodesDevicesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
 10227  	gensupport.SetOptions(c.urlParams_, opts...)
 10228  	res, err := c.doRequest("json")
 10229  	if res != nil && res.StatusCode == http.StatusNotModified {
 10230  		if res.Body != nil {
 10231  			res.Body.Close()
 10232  		}
 10233  		return nil, gensupport.WrapError(&googleapi.Error{
 10234  			Code:   res.StatusCode,
 10235  			Header: res.Header,
 10236  		})
 10237  	}
 10238  	if err != nil {
 10239  		return nil, err
 10240  	}
 10241  	defer googleapi.CloseBody(res)
 10242  	if err := googleapi.CheckResponse(res); err != nil {
 10243  		return nil, gensupport.WrapError(err)
 10244  	}
 10245  	ret := &SasPortalDevice{
 10246  		ServerResponse: googleapi.ServerResponse{
 10247  			Header:         res.Header,
 10248  			HTTPStatusCode: res.StatusCode,
 10249  		},
 10250  	}
 10251  	target := &ret
 10252  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10253  		return nil, err
 10254  	}
 10255  	return ret, nil
 10256  }
 10257  
 10258  type NodesNodesDevicesCreateSignedCall struct {
 10259  	s                                  *Service
 10260  	parent                             string
 10261  	sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest
 10262  	urlParams_                         gensupport.URLParams
 10263  	ctx_                               context.Context
 10264  	header_                            http.Header
 10265  }
 10266  
 10267  // CreateSigned: Creates a signed device under a node or customer.
 10268  //
 10269  // - parent: The name of the parent resource.
 10270  func (r *NodesNodesDevicesService) CreateSigned(parent string, sasportalcreatesigneddevicerequest *SasPortalCreateSignedDeviceRequest) *NodesNodesDevicesCreateSignedCall {
 10271  	c := &NodesNodesDevicesCreateSignedCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10272  	c.parent = parent
 10273  	c.sasportalcreatesigneddevicerequest = sasportalcreatesigneddevicerequest
 10274  	return c
 10275  }
 10276  
 10277  // Fields allows partial responses to be retrieved. See
 10278  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10279  // details.
 10280  func (c *NodesNodesDevicesCreateSignedCall) Fields(s ...googleapi.Field) *NodesNodesDevicesCreateSignedCall {
 10281  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10282  	return c
 10283  }
 10284  
 10285  // Context sets the context to be used in this call's Do method.
 10286  func (c *NodesNodesDevicesCreateSignedCall) Context(ctx context.Context) *NodesNodesDevicesCreateSignedCall {
 10287  	c.ctx_ = ctx
 10288  	return c
 10289  }
 10290  
 10291  // Header returns a http.Header that can be modified by the caller to add
 10292  // headers to the request.
 10293  func (c *NodesNodesDevicesCreateSignedCall) Header() http.Header {
 10294  	if c.header_ == nil {
 10295  		c.header_ = make(http.Header)
 10296  	}
 10297  	return c.header_
 10298  }
 10299  
 10300  func (c *NodesNodesDevicesCreateSignedCall) doRequest(alt string) (*http.Response, error) {
 10301  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 10302  	var body io.Reader = nil
 10303  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalcreatesigneddevicerequest)
 10304  	if err != nil {
 10305  		return nil, err
 10306  	}
 10307  	c.urlParams_.Set("alt", alt)
 10308  	c.urlParams_.Set("prettyPrint", "false")
 10309  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices:createSigned")
 10310  	urls += "?" + c.urlParams_.Encode()
 10311  	req, err := http.NewRequest("POST", urls, body)
 10312  	if err != nil {
 10313  		return nil, err
 10314  	}
 10315  	req.Header = reqHeaders
 10316  	googleapi.Expand(req.URL, map[string]string{
 10317  		"parent": c.parent,
 10318  	})
 10319  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10320  }
 10321  
 10322  // Do executes the "sasportal.nodes.nodes.devices.createSigned" call.
 10323  // Any non-2xx status code is an error. Response headers are in either
 10324  // *SasPortalDevice.ServerResponse.Header or (if a response was returned at
 10325  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
 10326  // check whether the returned error was because http.StatusNotModified was
 10327  // returned.
 10328  func (c *NodesNodesDevicesCreateSignedCall) Do(opts ...googleapi.CallOption) (*SasPortalDevice, error) {
 10329  	gensupport.SetOptions(c.urlParams_, opts...)
 10330  	res, err := c.doRequest("json")
 10331  	if res != nil && res.StatusCode == http.StatusNotModified {
 10332  		if res.Body != nil {
 10333  			res.Body.Close()
 10334  		}
 10335  		return nil, gensupport.WrapError(&googleapi.Error{
 10336  			Code:   res.StatusCode,
 10337  			Header: res.Header,
 10338  		})
 10339  	}
 10340  	if err != nil {
 10341  		return nil, err
 10342  	}
 10343  	defer googleapi.CloseBody(res)
 10344  	if err := googleapi.CheckResponse(res); err != nil {
 10345  		return nil, gensupport.WrapError(err)
 10346  	}
 10347  	ret := &SasPortalDevice{
 10348  		ServerResponse: googleapi.ServerResponse{
 10349  			Header:         res.Header,
 10350  			HTTPStatusCode: res.StatusCode,
 10351  		},
 10352  	}
 10353  	target := &ret
 10354  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10355  		return nil, err
 10356  	}
 10357  	return ret, nil
 10358  }
 10359  
 10360  type NodesNodesDevicesListCall struct {
 10361  	s            *Service
 10362  	parent       string
 10363  	urlParams_   gensupport.URLParams
 10364  	ifNoneMatch_ string
 10365  	ctx_         context.Context
 10366  	header_      http.Header
 10367  }
 10368  
 10369  // List: Lists devices under a node or customer.
 10370  //
 10371  // - parent: The name of the parent resource.
 10372  func (r *NodesNodesDevicesService) List(parent string) *NodesNodesDevicesListCall {
 10373  	c := &NodesNodesDevicesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10374  	c.parent = parent
 10375  	return c
 10376  }
 10377  
 10378  // Filter sets the optional parameter "filter": The filter expression. The
 10379  // filter should have one of the following formats: "sn=123454" or
 10380  // "display_name=MyDevice". sn corresponds to serial number of the device. The
 10381  // filter is case insensitive.
 10382  func (c *NodesNodesDevicesListCall) Filter(filter string) *NodesNodesDevicesListCall {
 10383  	c.urlParams_.Set("filter", filter)
 10384  	return c
 10385  }
 10386  
 10387  // PageSize sets the optional parameter "pageSize": The maximum number of
 10388  // devices to return in the response. If empty or zero, all devices will be
 10389  // listed. Must be in the range [0, 1000].
 10390  func (c *NodesNodesDevicesListCall) PageSize(pageSize int64) *NodesNodesDevicesListCall {
 10391  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
 10392  	return c
 10393  }
 10394  
 10395  // PageToken sets the optional parameter "pageToken": A pagination token
 10396  // returned from a previous call to ListDevices that indicates where this
 10397  // listing should continue from.
 10398  func (c *NodesNodesDevicesListCall) PageToken(pageToken string) *NodesNodesDevicesListCall {
 10399  	c.urlParams_.Set("pageToken", pageToken)
 10400  	return c
 10401  }
 10402  
 10403  // Fields allows partial responses to be retrieved. See
 10404  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10405  // details.
 10406  func (c *NodesNodesDevicesListCall) Fields(s ...googleapi.Field) *NodesNodesDevicesListCall {
 10407  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10408  	return c
 10409  }
 10410  
 10411  // IfNoneMatch sets an optional parameter which makes the operation fail if the
 10412  // object's ETag matches the given value. This is useful for getting updates
 10413  // only after the object has changed since the last request.
 10414  func (c *NodesNodesDevicesListCall) IfNoneMatch(entityTag string) *NodesNodesDevicesListCall {
 10415  	c.ifNoneMatch_ = entityTag
 10416  	return c
 10417  }
 10418  
 10419  // Context sets the context to be used in this call's Do method.
 10420  func (c *NodesNodesDevicesListCall) Context(ctx context.Context) *NodesNodesDevicesListCall {
 10421  	c.ctx_ = ctx
 10422  	return c
 10423  }
 10424  
 10425  // Header returns a http.Header that can be modified by the caller to add
 10426  // headers to the request.
 10427  func (c *NodesNodesDevicesListCall) Header() http.Header {
 10428  	if c.header_ == nil {
 10429  		c.header_ = make(http.Header)
 10430  	}
 10431  	return c.header_
 10432  }
 10433  
 10434  func (c *NodesNodesDevicesListCall) doRequest(alt string) (*http.Response, error) {
 10435  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
 10436  	if c.ifNoneMatch_ != "" {
 10437  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
 10438  	}
 10439  	var body io.Reader = nil
 10440  	c.urlParams_.Set("alt", alt)
 10441  	c.urlParams_.Set("prettyPrint", "false")
 10442  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/devices")
 10443  	urls += "?" + c.urlParams_.Encode()
 10444  	req, err := http.NewRequest("GET", urls, body)
 10445  	if err != nil {
 10446  		return nil, err
 10447  	}
 10448  	req.Header = reqHeaders
 10449  	googleapi.Expand(req.URL, map[string]string{
 10450  		"parent": c.parent,
 10451  	})
 10452  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10453  }
 10454  
 10455  // Do executes the "sasportal.nodes.nodes.devices.list" call.
 10456  // Any non-2xx status code is an error. Response headers are in either
 10457  // *SasPortalListDevicesResponse.ServerResponse.Header or (if a response was
 10458  // returned at all) in error.(*googleapi.Error).Header. Use
 10459  // googleapi.IsNotModified to check whether the returned error was because
 10460  // http.StatusNotModified was returned.
 10461  func (c *NodesNodesDevicesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListDevicesResponse, error) {
 10462  	gensupport.SetOptions(c.urlParams_, opts...)
 10463  	res, err := c.doRequest("json")
 10464  	if res != nil && res.StatusCode == http.StatusNotModified {
 10465  		if res.Body != nil {
 10466  			res.Body.Close()
 10467  		}
 10468  		return nil, gensupport.WrapError(&googleapi.Error{
 10469  			Code:   res.StatusCode,
 10470  			Header: res.Header,
 10471  		})
 10472  	}
 10473  	if err != nil {
 10474  		return nil, err
 10475  	}
 10476  	defer googleapi.CloseBody(res)
 10477  	if err := googleapi.CheckResponse(res); err != nil {
 10478  		return nil, gensupport.WrapError(err)
 10479  	}
 10480  	ret := &SasPortalListDevicesResponse{
 10481  		ServerResponse: googleapi.ServerResponse{
 10482  			Header:         res.Header,
 10483  			HTTPStatusCode: res.StatusCode,
 10484  		},
 10485  	}
 10486  	target := &ret
 10487  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10488  		return nil, err
 10489  	}
 10490  	return ret, nil
 10491  }
 10492  
 10493  // Pages invokes f for each page of results.
 10494  // A non-nil error returned from f will halt the iteration.
 10495  // The provided context supersedes any context provided to the Context method.
 10496  func (c *NodesNodesDevicesListCall) Pages(ctx context.Context, f func(*SasPortalListDevicesResponse) error) error {
 10497  	c.ctx_ = ctx
 10498  	defer c.PageToken(c.urlParams_.Get("pageToken"))
 10499  	for {
 10500  		x, err := c.Do()
 10501  		if err != nil {
 10502  			return err
 10503  		}
 10504  		if err := f(x); err != nil {
 10505  			return err
 10506  		}
 10507  		if x.NextPageToken == "" {
 10508  			return nil
 10509  		}
 10510  		c.PageToken(x.NextPageToken)
 10511  	}
 10512  }
 10513  
 10514  type NodesNodesNodesCreateCall struct {
 10515  	s             *Service
 10516  	parent        string
 10517  	sasportalnode *SasPortalNode
 10518  	urlParams_    gensupport.URLParams
 10519  	ctx_          context.Context
 10520  	header_       http.Header
 10521  }
 10522  
 10523  // Create: Creates a new node.
 10524  //
 10525  // - parent: The parent resource name where the node is to be created.
 10526  func (r *NodesNodesNodesService) Create(parent string, sasportalnode *SasPortalNode) *NodesNodesNodesCreateCall {
 10527  	c := &NodesNodesNodesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10528  	c.parent = parent
 10529  	c.sasportalnode = sasportalnode
 10530  	return c
 10531  }
 10532  
 10533  // Fields allows partial responses to be retrieved. See
 10534  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10535  // details.
 10536  func (c *NodesNodesNodesCreateCall) Fields(s ...googleapi.Field) *NodesNodesNodesCreateCall {
 10537  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10538  	return c
 10539  }
 10540  
 10541  // Context sets the context to be used in this call's Do method.
 10542  func (c *NodesNodesNodesCreateCall) Context(ctx context.Context) *NodesNodesNodesCreateCall {
 10543  	c.ctx_ = ctx
 10544  	return c
 10545  }
 10546  
 10547  // Header returns a http.Header that can be modified by the caller to add
 10548  // headers to the request.
 10549  func (c *NodesNodesNodesCreateCall) Header() http.Header {
 10550  	if c.header_ == nil {
 10551  		c.header_ = make(http.Header)
 10552  	}
 10553  	return c.header_
 10554  }
 10555  
 10556  func (c *NodesNodesNodesCreateCall) doRequest(alt string) (*http.Response, error) {
 10557  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 10558  	var body io.Reader = nil
 10559  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalnode)
 10560  	if err != nil {
 10561  		return nil, err
 10562  	}
 10563  	c.urlParams_.Set("alt", alt)
 10564  	c.urlParams_.Set("prettyPrint", "false")
 10565  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
 10566  	urls += "?" + c.urlParams_.Encode()
 10567  	req, err := http.NewRequest("POST", urls, body)
 10568  	if err != nil {
 10569  		return nil, err
 10570  	}
 10571  	req.Header = reqHeaders
 10572  	googleapi.Expand(req.URL, map[string]string{
 10573  		"parent": c.parent,
 10574  	})
 10575  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10576  }
 10577  
 10578  // Do executes the "sasportal.nodes.nodes.nodes.create" call.
 10579  // Any non-2xx status code is an error. Response headers are in either
 10580  // *SasPortalNode.ServerResponse.Header or (if a response was returned at all)
 10581  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check
 10582  // whether the returned error was because http.StatusNotModified was returned.
 10583  func (c *NodesNodesNodesCreateCall) Do(opts ...googleapi.CallOption) (*SasPortalNode, error) {
 10584  	gensupport.SetOptions(c.urlParams_, opts...)
 10585  	res, err := c.doRequest("json")
 10586  	if res != nil && res.StatusCode == http.StatusNotModified {
 10587  		if res.Body != nil {
 10588  			res.Body.Close()
 10589  		}
 10590  		return nil, gensupport.WrapError(&googleapi.Error{
 10591  			Code:   res.StatusCode,
 10592  			Header: res.Header,
 10593  		})
 10594  	}
 10595  	if err != nil {
 10596  		return nil, err
 10597  	}
 10598  	defer googleapi.CloseBody(res)
 10599  	if err := googleapi.CheckResponse(res); err != nil {
 10600  		return nil, gensupport.WrapError(err)
 10601  	}
 10602  	ret := &SasPortalNode{
 10603  		ServerResponse: googleapi.ServerResponse{
 10604  			Header:         res.Header,
 10605  			HTTPStatusCode: res.StatusCode,
 10606  		},
 10607  	}
 10608  	target := &ret
 10609  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10610  		return nil, err
 10611  	}
 10612  	return ret, nil
 10613  }
 10614  
 10615  type NodesNodesNodesListCall struct {
 10616  	s            *Service
 10617  	parent       string
 10618  	urlParams_   gensupport.URLParams
 10619  	ifNoneMatch_ string
 10620  	ctx_         context.Context
 10621  	header_      http.Header
 10622  }
 10623  
 10624  // List: Lists nodes.
 10625  //
 10626  // - parent: The parent resource name, for example, "nodes/1".
 10627  func (r *NodesNodesNodesService) List(parent string) *NodesNodesNodesListCall {
 10628  	c := &NodesNodesNodesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10629  	c.parent = parent
 10630  	return c
 10631  }
 10632  
 10633  // Filter sets the optional parameter "filter": The filter expression. The
 10634  // filter should have the following format: "DIRECT_CHILDREN" or format:
 10635  // "direct_children". The filter is case insensitive. If empty, then no nodes
 10636  // are filtered.
 10637  func (c *NodesNodesNodesListCall) Filter(filter string) *NodesNodesNodesListCall {
 10638  	c.urlParams_.Set("filter", filter)
 10639  	return c
 10640  }
 10641  
 10642  // PageSize sets the optional parameter "pageSize": The maximum number of nodes
 10643  // to return in the response.
 10644  func (c *NodesNodesNodesListCall) PageSize(pageSize int64) *NodesNodesNodesListCall {
 10645  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
 10646  	return c
 10647  }
 10648  
 10649  // PageToken sets the optional parameter "pageToken": A pagination token
 10650  // returned from a previous call to ListNodes that indicates where this listing
 10651  // should continue from.
 10652  func (c *NodesNodesNodesListCall) PageToken(pageToken string) *NodesNodesNodesListCall {
 10653  	c.urlParams_.Set("pageToken", pageToken)
 10654  	return c
 10655  }
 10656  
 10657  // Fields allows partial responses to be retrieved. See
 10658  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10659  // details.
 10660  func (c *NodesNodesNodesListCall) Fields(s ...googleapi.Field) *NodesNodesNodesListCall {
 10661  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10662  	return c
 10663  }
 10664  
 10665  // IfNoneMatch sets an optional parameter which makes the operation fail if the
 10666  // object's ETag matches the given value. This is useful for getting updates
 10667  // only after the object has changed since the last request.
 10668  func (c *NodesNodesNodesListCall) IfNoneMatch(entityTag string) *NodesNodesNodesListCall {
 10669  	c.ifNoneMatch_ = entityTag
 10670  	return c
 10671  }
 10672  
 10673  // Context sets the context to be used in this call's Do method.
 10674  func (c *NodesNodesNodesListCall) Context(ctx context.Context) *NodesNodesNodesListCall {
 10675  	c.ctx_ = ctx
 10676  	return c
 10677  }
 10678  
 10679  // Header returns a http.Header that can be modified by the caller to add
 10680  // headers to the request.
 10681  func (c *NodesNodesNodesListCall) Header() http.Header {
 10682  	if c.header_ == nil {
 10683  		c.header_ = make(http.Header)
 10684  	}
 10685  	return c.header_
 10686  }
 10687  
 10688  func (c *NodesNodesNodesListCall) doRequest(alt string) (*http.Response, error) {
 10689  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_)
 10690  	if c.ifNoneMatch_ != "" {
 10691  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
 10692  	}
 10693  	var body io.Reader = nil
 10694  	c.urlParams_.Set("alt", alt)
 10695  	c.urlParams_.Set("prettyPrint", "false")
 10696  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/{+parent}/nodes")
 10697  	urls += "?" + c.urlParams_.Encode()
 10698  	req, err := http.NewRequest("GET", urls, body)
 10699  	if err != nil {
 10700  		return nil, err
 10701  	}
 10702  	req.Header = reqHeaders
 10703  	googleapi.Expand(req.URL, map[string]string{
 10704  		"parent": c.parent,
 10705  	})
 10706  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10707  }
 10708  
 10709  // Do executes the "sasportal.nodes.nodes.nodes.list" call.
 10710  // Any non-2xx status code is an error. Response headers are in either
 10711  // *SasPortalListNodesResponse.ServerResponse.Header or (if a response was
 10712  // returned at all) in error.(*googleapi.Error).Header. Use
 10713  // googleapi.IsNotModified to check whether the returned error was because
 10714  // http.StatusNotModified was returned.
 10715  func (c *NodesNodesNodesListCall) Do(opts ...googleapi.CallOption) (*SasPortalListNodesResponse, error) {
 10716  	gensupport.SetOptions(c.urlParams_, opts...)
 10717  	res, err := c.doRequest("json")
 10718  	if res != nil && res.StatusCode == http.StatusNotModified {
 10719  		if res.Body != nil {
 10720  			res.Body.Close()
 10721  		}
 10722  		return nil, gensupport.WrapError(&googleapi.Error{
 10723  			Code:   res.StatusCode,
 10724  			Header: res.Header,
 10725  		})
 10726  	}
 10727  	if err != nil {
 10728  		return nil, err
 10729  	}
 10730  	defer googleapi.CloseBody(res)
 10731  	if err := googleapi.CheckResponse(res); err != nil {
 10732  		return nil, gensupport.WrapError(err)
 10733  	}
 10734  	ret := &SasPortalListNodesResponse{
 10735  		ServerResponse: googleapi.ServerResponse{
 10736  			Header:         res.Header,
 10737  			HTTPStatusCode: res.StatusCode,
 10738  		},
 10739  	}
 10740  	target := &ret
 10741  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10742  		return nil, err
 10743  	}
 10744  	return ret, nil
 10745  }
 10746  
 10747  // Pages invokes f for each page of results.
 10748  // A non-nil error returned from f will halt the iteration.
 10749  // The provided context supersedes any context provided to the Context method.
 10750  func (c *NodesNodesNodesListCall) Pages(ctx context.Context, f func(*SasPortalListNodesResponse) error) error {
 10751  	c.ctx_ = ctx
 10752  	defer c.PageToken(c.urlParams_.Get("pageToken"))
 10753  	for {
 10754  		x, err := c.Do()
 10755  		if err != nil {
 10756  			return err
 10757  		}
 10758  		if err := f(x); err != nil {
 10759  			return err
 10760  		}
 10761  		if x.NextPageToken == "" {
 10762  			return nil
 10763  		}
 10764  		c.PageToken(x.NextPageToken)
 10765  	}
 10766  }
 10767  
 10768  type PoliciesGetCall struct {
 10769  	s                         *Service
 10770  	sasportalgetpolicyrequest *SasPortalGetPolicyRequest
 10771  	urlParams_                gensupport.URLParams
 10772  	ctx_                      context.Context
 10773  	header_                   http.Header
 10774  }
 10775  
 10776  // Get: Gets the access control policy for a resource. Returns an empty policy
 10777  // if the resource exists and does not have a policy set.
 10778  func (r *PoliciesService) Get(sasportalgetpolicyrequest *SasPortalGetPolicyRequest) *PoliciesGetCall {
 10779  	c := &PoliciesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10780  	c.sasportalgetpolicyrequest = sasportalgetpolicyrequest
 10781  	return c
 10782  }
 10783  
 10784  // Fields allows partial responses to be retrieved. See
 10785  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10786  // details.
 10787  func (c *PoliciesGetCall) Fields(s ...googleapi.Field) *PoliciesGetCall {
 10788  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10789  	return c
 10790  }
 10791  
 10792  // Context sets the context to be used in this call's Do method.
 10793  func (c *PoliciesGetCall) Context(ctx context.Context) *PoliciesGetCall {
 10794  	c.ctx_ = ctx
 10795  	return c
 10796  }
 10797  
 10798  // Header returns a http.Header that can be modified by the caller to add
 10799  // headers to the request.
 10800  func (c *PoliciesGetCall) Header() http.Header {
 10801  	if c.header_ == nil {
 10802  		c.header_ = make(http.Header)
 10803  	}
 10804  	return c.header_
 10805  }
 10806  
 10807  func (c *PoliciesGetCall) doRequest(alt string) (*http.Response, error) {
 10808  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 10809  	var body io.Reader = nil
 10810  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalgetpolicyrequest)
 10811  	if err != nil {
 10812  		return nil, err
 10813  	}
 10814  	c.urlParams_.Set("alt", alt)
 10815  	c.urlParams_.Set("prettyPrint", "false")
 10816  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/policies:get")
 10817  	urls += "?" + c.urlParams_.Encode()
 10818  	req, err := http.NewRequest("POST", urls, body)
 10819  	if err != nil {
 10820  		return nil, err
 10821  	}
 10822  	req.Header = reqHeaders
 10823  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10824  }
 10825  
 10826  // Do executes the "sasportal.policies.get" call.
 10827  // Any non-2xx status code is an error. Response headers are in either
 10828  // *SasPortalPolicy.ServerResponse.Header or (if a response was returned at
 10829  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
 10830  // check whether the returned error was because http.StatusNotModified was
 10831  // returned.
 10832  func (c *PoliciesGetCall) Do(opts ...googleapi.CallOption) (*SasPortalPolicy, error) {
 10833  	gensupport.SetOptions(c.urlParams_, opts...)
 10834  	res, err := c.doRequest("json")
 10835  	if res != nil && res.StatusCode == http.StatusNotModified {
 10836  		if res.Body != nil {
 10837  			res.Body.Close()
 10838  		}
 10839  		return nil, gensupport.WrapError(&googleapi.Error{
 10840  			Code:   res.StatusCode,
 10841  			Header: res.Header,
 10842  		})
 10843  	}
 10844  	if err != nil {
 10845  		return nil, err
 10846  	}
 10847  	defer googleapi.CloseBody(res)
 10848  	if err := googleapi.CheckResponse(res); err != nil {
 10849  		return nil, gensupport.WrapError(err)
 10850  	}
 10851  	ret := &SasPortalPolicy{
 10852  		ServerResponse: googleapi.ServerResponse{
 10853  			Header:         res.Header,
 10854  			HTTPStatusCode: res.StatusCode,
 10855  		},
 10856  	}
 10857  	target := &ret
 10858  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10859  		return nil, err
 10860  	}
 10861  	return ret, nil
 10862  }
 10863  
 10864  type PoliciesSetCall struct {
 10865  	s                         *Service
 10866  	sasportalsetpolicyrequest *SasPortalSetPolicyRequest
 10867  	urlParams_                gensupport.URLParams
 10868  	ctx_                      context.Context
 10869  	header_                   http.Header
 10870  }
 10871  
 10872  // Set: Sets the access control policy on the specified resource. Replaces any
 10873  // existing policy.
 10874  func (r *PoliciesService) Set(sasportalsetpolicyrequest *SasPortalSetPolicyRequest) *PoliciesSetCall {
 10875  	c := &PoliciesSetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10876  	c.sasportalsetpolicyrequest = sasportalsetpolicyrequest
 10877  	return c
 10878  }
 10879  
 10880  // Fields allows partial responses to be retrieved. See
 10881  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10882  // details.
 10883  func (c *PoliciesSetCall) Fields(s ...googleapi.Field) *PoliciesSetCall {
 10884  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10885  	return c
 10886  }
 10887  
 10888  // Context sets the context to be used in this call's Do method.
 10889  func (c *PoliciesSetCall) Context(ctx context.Context) *PoliciesSetCall {
 10890  	c.ctx_ = ctx
 10891  	return c
 10892  }
 10893  
 10894  // Header returns a http.Header that can be modified by the caller to add
 10895  // headers to the request.
 10896  func (c *PoliciesSetCall) Header() http.Header {
 10897  	if c.header_ == nil {
 10898  		c.header_ = make(http.Header)
 10899  	}
 10900  	return c.header_
 10901  }
 10902  
 10903  func (c *PoliciesSetCall) doRequest(alt string) (*http.Response, error) {
 10904  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 10905  	var body io.Reader = nil
 10906  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportalsetpolicyrequest)
 10907  	if err != nil {
 10908  		return nil, err
 10909  	}
 10910  	c.urlParams_.Set("alt", alt)
 10911  	c.urlParams_.Set("prettyPrint", "false")
 10912  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/policies:set")
 10913  	urls += "?" + c.urlParams_.Encode()
 10914  	req, err := http.NewRequest("POST", urls, body)
 10915  	if err != nil {
 10916  		return nil, err
 10917  	}
 10918  	req.Header = reqHeaders
 10919  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 10920  }
 10921  
 10922  // Do executes the "sasportal.policies.set" call.
 10923  // Any non-2xx status code is an error. Response headers are in either
 10924  // *SasPortalPolicy.ServerResponse.Header or (if a response was returned at
 10925  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
 10926  // check whether the returned error was because http.StatusNotModified was
 10927  // returned.
 10928  func (c *PoliciesSetCall) Do(opts ...googleapi.CallOption) (*SasPortalPolicy, error) {
 10929  	gensupport.SetOptions(c.urlParams_, opts...)
 10930  	res, err := c.doRequest("json")
 10931  	if res != nil && res.StatusCode == http.StatusNotModified {
 10932  		if res.Body != nil {
 10933  			res.Body.Close()
 10934  		}
 10935  		return nil, gensupport.WrapError(&googleapi.Error{
 10936  			Code:   res.StatusCode,
 10937  			Header: res.Header,
 10938  		})
 10939  	}
 10940  	if err != nil {
 10941  		return nil, err
 10942  	}
 10943  	defer googleapi.CloseBody(res)
 10944  	if err := googleapi.CheckResponse(res); err != nil {
 10945  		return nil, gensupport.WrapError(err)
 10946  	}
 10947  	ret := &SasPortalPolicy{
 10948  		ServerResponse: googleapi.ServerResponse{
 10949  			Header:         res.Header,
 10950  			HTTPStatusCode: res.StatusCode,
 10951  		},
 10952  	}
 10953  	target := &ret
 10954  	if err := gensupport.DecodeResponse(target, res); err != nil {
 10955  		return nil, err
 10956  	}
 10957  	return ret, nil
 10958  }
 10959  
 10960  type PoliciesTestCall struct {
 10961  	s                               *Service
 10962  	sasportaltestpermissionsrequest *SasPortalTestPermissionsRequest
 10963  	urlParams_                      gensupport.URLParams
 10964  	ctx_                            context.Context
 10965  	header_                         http.Header
 10966  }
 10967  
 10968  // Test: Returns permissions that a caller has on the specified resource.
 10969  func (r *PoliciesService) Test(sasportaltestpermissionsrequest *SasPortalTestPermissionsRequest) *PoliciesTestCall {
 10970  	c := &PoliciesTestCall{s: r.s, urlParams_: make(gensupport.URLParams)}
 10971  	c.sasportaltestpermissionsrequest = sasportaltestpermissionsrequest
 10972  	return c
 10973  }
 10974  
 10975  // Fields allows partial responses to be retrieved. See
 10976  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more
 10977  // details.
 10978  func (c *PoliciesTestCall) Fields(s ...googleapi.Field) *PoliciesTestCall {
 10979  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
 10980  	return c
 10981  }
 10982  
 10983  // Context sets the context to be used in this call's Do method.
 10984  func (c *PoliciesTestCall) Context(ctx context.Context) *PoliciesTestCall {
 10985  	c.ctx_ = ctx
 10986  	return c
 10987  }
 10988  
 10989  // Header returns a http.Header that can be modified by the caller to add
 10990  // headers to the request.
 10991  func (c *PoliciesTestCall) Header() http.Header {
 10992  	if c.header_ == nil {
 10993  		c.header_ = make(http.Header)
 10994  	}
 10995  	return c.header_
 10996  }
 10997  
 10998  func (c *PoliciesTestCall) doRequest(alt string) (*http.Response, error) {
 10999  	reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_)
 11000  	var body io.Reader = nil
 11001  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.sasportaltestpermissionsrequest)
 11002  	if err != nil {
 11003  		return nil, err
 11004  	}
 11005  	c.urlParams_.Set("alt", alt)
 11006  	c.urlParams_.Set("prettyPrint", "false")
 11007  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha1/policies:test")
 11008  	urls += "?" + c.urlParams_.Encode()
 11009  	req, err := http.NewRequest("POST", urls, body)
 11010  	if err != nil {
 11011  		return nil, err
 11012  	}
 11013  	req.Header = reqHeaders
 11014  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
 11015  }
 11016  
 11017  // Do executes the "sasportal.policies.test" call.
 11018  // Any non-2xx status code is an error. Response headers are in either
 11019  // *SasPortalTestPermissionsResponse.ServerResponse.Header or (if a response
 11020  // was returned at all) in error.(*googleapi.Error).Header. Use
 11021  // googleapi.IsNotModified to check whether the returned error was because
 11022  // http.StatusNotModified was returned.
 11023  func (c *PoliciesTestCall) Do(opts ...googleapi.CallOption) (*SasPortalTestPermissionsResponse, error) {
 11024  	gensupport.SetOptions(c.urlParams_, opts...)
 11025  	res, err := c.doRequest("json")
 11026  	if res != nil && res.StatusCode == http.StatusNotModified {
 11027  		if res.Body != nil {
 11028  			res.Body.Close()
 11029  		}
 11030  		return nil, gensupport.WrapError(&googleapi.Error{
 11031  			Code:   res.StatusCode,
 11032  			Header: res.Header,
 11033  		})
 11034  	}
 11035  	if err != nil {
 11036  		return nil, err
 11037  	}
 11038  	defer googleapi.CloseBody(res)
 11039  	if err := googleapi.CheckResponse(res); err != nil {
 11040  		return nil, gensupport.WrapError(err)
 11041  	}
 11042  	ret := &SasPortalTestPermissionsResponse{
 11043  		ServerResponse: googleapi.ServerResponse{
 11044  			Header:         res.Header,
 11045  			HTTPStatusCode: res.StatusCode,
 11046  		},
 11047  	}
 11048  	target := &ret
 11049  	if err := gensupport.DecodeResponse(target, res); err != nil {
 11050  		return nil, err
 11051  	}
 11052  	return ret, nil
 11053  }
 11054  

View as plain text