Source file src/google.golang.org/api/genomics/v1alpha2/genomics-gen.go

Documentation: google.golang.org/api/genomics/v1alpha2

     1  // Copyright 2021 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 genomics provides access to the Genomics API.
     8  //
     9  // For product documentation, see: https://cloud.google.com/genomics
    10  //
    11  // # Creating a client
    12  //
    13  // Usage example:
    14  //
    15  //	import "google.golang.org/api/genomics/v1alpha2"
    16  //	...
    17  //	ctx := context.Background()
    18  //	genomicsService, err := genomics.NewService(ctx)
    19  //
    20  // In this example, Google Application Default Credentials are used for authentication.
    21  //
    22  // For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.
    23  //
    24  // # Other authentication options
    25  //
    26  // By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:
    27  //
    28  //	genomicsService, err := genomics.NewService(ctx, option.WithScopes(genomics.GenomicsScope))
    29  //
    30  // To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:
    31  //
    32  //	genomicsService, err := genomics.NewService(ctx, option.WithAPIKey("AIza..."))
    33  //
    34  // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:
    35  //
    36  //	config := &oauth2.Config{...}
    37  //	// ...
    38  //	token, err := config.Exchange(ctx, ...)
    39  //	genomicsService, err := genomics.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))
    40  //
    41  // See https://godoc.org/google.golang.org/api/option/ for details on options.
    42  package genomics // import "google.golang.org/api/genomics/v1alpha2"
    43  
    44  import (
    45  	"bytes"
    46  	"context"
    47  	"encoding/json"
    48  	"errors"
    49  	"fmt"
    50  	"io"
    51  	"net/http"
    52  	"net/url"
    53  	"strconv"
    54  	"strings"
    55  
    56  	googleapi "google.golang.org/api/googleapi"
    57  	gensupport "google.golang.org/api/internal/gensupport"
    58  	option "google.golang.org/api/option"
    59  	internaloption "google.golang.org/api/option/internaloption"
    60  	htransport "google.golang.org/api/transport/http"
    61  )
    62  
    63  // Always reference these packages, just in case the auto-generated code
    64  // below doesn't.
    65  var _ = bytes.NewBuffer
    66  var _ = strconv.Itoa
    67  var _ = fmt.Sprintf
    68  var _ = json.NewDecoder
    69  var _ = io.Copy
    70  var _ = url.Parse
    71  var _ = gensupport.MarshalJSON
    72  var _ = googleapi.Version
    73  var _ = errors.New
    74  var _ = strings.Replace
    75  var _ = context.Canceled
    76  var _ = internaloption.WithDefaultEndpoint
    77  
    78  const apiId = "genomics:v1alpha2"
    79  const apiName = "genomics"
    80  const apiVersion = "v1alpha2"
    81  const basePath = "https://genomics.googleapis.com/"
    82  const mtlsBasePath = "https://genomics.mtls.googleapis.com/"
    83  
    84  // OAuth2 scopes used by this API.
    85  const (
    86  	// See, edit, configure, and delete your Google Cloud Platform data
    87  	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
    88  
    89  	// View and manage your Google Compute Engine resources
    90  	ComputeScope = "https://www.googleapis.com/auth/compute"
    91  
    92  	// View and manage Genomics data
    93  	GenomicsScope = "https://www.googleapis.com/auth/genomics"
    94  )
    95  
    96  // NewService creates a new Service.
    97  func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
    98  	scopesOption := option.WithScopes(
    99  		"https://www.googleapis.com/auth/cloud-platform",
   100  		"https://www.googleapis.com/auth/compute",
   101  		"https://www.googleapis.com/auth/genomics",
   102  	)
   103  	// NOTE: prepend, so we don't override user-specified scopes.
   104  	opts = append([]option.ClientOption{scopesOption}, opts...)
   105  	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
   106  	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
   107  	client, endpoint, err := htransport.NewClient(ctx, opts...)
   108  	if err != nil {
   109  		return nil, err
   110  	}
   111  	s, err := New(client)
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  	if endpoint != "" {
   116  		s.BasePath = endpoint
   117  	}
   118  	return s, nil
   119  }
   120  
   121  // New creates a new Service. It uses the provided http.Client for requests.
   122  //
   123  // Deprecated: please use NewService instead.
   124  // To provide a custom HTTP client, use option.WithHTTPClient.
   125  // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.
   126  func New(client *http.Client) (*Service, error) {
   127  	if client == nil {
   128  		return nil, errors.New("client is nil")
   129  	}
   130  	s := &Service{client: client, BasePath: basePath}
   131  	s.Operations = NewOperationsService(s)
   132  	s.Pipelines = NewPipelinesService(s)
   133  	return s, nil
   134  }
   135  
   136  type Service struct {
   137  	client    *http.Client
   138  	BasePath  string // API endpoint base URL
   139  	UserAgent string // optional additional User-Agent fragment
   140  
   141  	Operations *OperationsService
   142  
   143  	Pipelines *PipelinesService
   144  }
   145  
   146  func (s *Service) userAgent() string {
   147  	if s.UserAgent == "" {
   148  		return googleapi.UserAgent
   149  	}
   150  	return googleapi.UserAgent + " " + s.UserAgent
   151  }
   152  
   153  func NewOperationsService(s *Service) *OperationsService {
   154  	rs := &OperationsService{s: s}
   155  	return rs
   156  }
   157  
   158  type OperationsService struct {
   159  	s *Service
   160  }
   161  
   162  func NewPipelinesService(s *Service) *PipelinesService {
   163  	rs := &PipelinesService{s: s}
   164  	return rs
   165  }
   166  
   167  type PipelinesService struct {
   168  	s *Service
   169  }
   170  
   171  // CancelOperationRequest: The request message for
   172  // Operations.CancelOperation.
   173  type CancelOperationRequest struct {
   174  }
   175  
   176  // ComputeEngine: Describes a Compute Engine resource that is being
   177  // managed by a running pipeline.
   178  type ComputeEngine struct {
   179  	// DiskNames: The names of the disks that were created for this
   180  	// pipeline.
   181  	DiskNames []string `json:"diskNames,omitempty"`
   182  
   183  	// InstanceName: The instance on which the operation is running.
   184  	InstanceName string `json:"instanceName,omitempty"`
   185  
   186  	// MachineType: The machine type of the instance.
   187  	MachineType string `json:"machineType,omitempty"`
   188  
   189  	// Zone: The availability zone in which the instance resides.
   190  	Zone string `json:"zone,omitempty"`
   191  
   192  	// ForceSendFields is a list of field names (e.g. "DiskNames") to
   193  	// unconditionally include in API requests. By default, fields with
   194  	// empty values are omitted from API requests. However, any non-pointer,
   195  	// non-interface field appearing in ForceSendFields will be sent to the
   196  	// server regardless of whether the field is empty or not. This may be
   197  	// used to include empty fields in Patch requests.
   198  	ForceSendFields []string `json:"-"`
   199  
   200  	// NullFields is a list of field names (e.g. "DiskNames") to include in
   201  	// API requests with the JSON null value. By default, fields with empty
   202  	// values are omitted from API requests. However, any field with an
   203  	// empty value appearing in NullFields will be sent to the server as
   204  	// null. It is an error if a field in this list has a non-empty value.
   205  	// This may be used to include null fields in Patch requests.
   206  	NullFields []string `json:"-"`
   207  }
   208  
   209  func (s *ComputeEngine) MarshalJSON() ([]byte, error) {
   210  	type NoMethod ComputeEngine
   211  	raw := NoMethod(*s)
   212  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   213  }
   214  
   215  // ContainerKilledEvent: An event generated when a container is forcibly
   216  // terminated by the worker. Currently, this only occurs when the
   217  // container outlives the timeout specified by the user.
   218  type ContainerKilledEvent struct {
   219  	// ActionId: The numeric ID of the action that started the container.
   220  	ActionId int64 `json:"actionId,omitempty"`
   221  
   222  	// ForceSendFields is a list of field names (e.g. "ActionId") to
   223  	// unconditionally include in API requests. By default, fields with
   224  	// empty values are omitted from API requests. However, any non-pointer,
   225  	// non-interface field appearing in ForceSendFields will be sent to the
   226  	// server regardless of whether the field is empty or not. This may be
   227  	// used to include empty fields in Patch requests.
   228  	ForceSendFields []string `json:"-"`
   229  
   230  	// NullFields is a list of field names (e.g. "ActionId") to include in
   231  	// API requests with the JSON null value. By default, fields with empty
   232  	// values are omitted from API requests. However, any field with an
   233  	// empty value appearing in NullFields will be sent to the server as
   234  	// null. It is an error if a field in this list has a non-empty value.
   235  	// This may be used to include null fields in Patch requests.
   236  	NullFields []string `json:"-"`
   237  }
   238  
   239  func (s *ContainerKilledEvent) MarshalJSON() ([]byte, error) {
   240  	type NoMethod ContainerKilledEvent
   241  	raw := NoMethod(*s)
   242  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   243  }
   244  
   245  // ContainerStartedEvent: An event generated when a container starts.
   246  type ContainerStartedEvent struct {
   247  	// ActionId: The numeric ID of the action that started this container.
   248  	ActionId int64 `json:"actionId,omitempty"`
   249  
   250  	// IpAddress: The public IP address that can be used to connect to the
   251  	// container. This field is only populated when at least one port
   252  	// mapping is present. If the instance was created with a private
   253  	// address, this field will be empty even if port mappings exist.
   254  	IpAddress string `json:"ipAddress,omitempty"`
   255  
   256  	// PortMappings: The container-to-host port mappings installed for this
   257  	// container. This set will contain any ports exposed using the
   258  	// `PUBLISH_EXPOSED_PORTS` flag as well as any specified in the `Action`
   259  	// definition.
   260  	PortMappings map[string]int64 `json:"portMappings,omitempty"`
   261  
   262  	// ForceSendFields is a list of field names (e.g. "ActionId") to
   263  	// unconditionally include in API requests. By default, fields with
   264  	// empty values are omitted from API requests. However, any non-pointer,
   265  	// non-interface field appearing in ForceSendFields will be sent to the
   266  	// server regardless of whether the field is empty or not. This may be
   267  	// used to include empty fields in Patch requests.
   268  	ForceSendFields []string `json:"-"`
   269  
   270  	// NullFields is a list of field names (e.g. "ActionId") to include in
   271  	// API requests with the JSON null value. By default, fields with empty
   272  	// values are omitted from API requests. However, any field with an
   273  	// empty value appearing in NullFields will be sent to the server as
   274  	// null. It is an error if a field in this list has a non-empty value.
   275  	// This may be used to include null fields in Patch requests.
   276  	NullFields []string `json:"-"`
   277  }
   278  
   279  func (s *ContainerStartedEvent) MarshalJSON() ([]byte, error) {
   280  	type NoMethod ContainerStartedEvent
   281  	raw := NoMethod(*s)
   282  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   283  }
   284  
   285  // ContainerStoppedEvent: An event generated when a container exits.
   286  type ContainerStoppedEvent struct {
   287  	// ActionId: The numeric ID of the action that started this container.
   288  	ActionId int64 `json:"actionId,omitempty"`
   289  
   290  	// ExitStatus: The exit status of the container.
   291  	ExitStatus int64 `json:"exitStatus,omitempty"`
   292  
   293  	// Stderr: The tail end of any content written to standard error by the
   294  	// container. If the content emits large amounts of debugging noise or
   295  	// contains sensitive information, you can prevent the content from
   296  	// being printed by setting the `DISABLE_STANDARD_ERROR_CAPTURE` flag.
   297  	// Note that only a small amount of the end of the stream is captured
   298  	// here. The entire stream is stored in the `/google/logs` directory
   299  	// mounted into each action, and can be copied off the machine as
   300  	// described elsewhere.
   301  	Stderr string `json:"stderr,omitempty"`
   302  
   303  	// ForceSendFields is a list of field names (e.g. "ActionId") to
   304  	// unconditionally include in API requests. By default, fields with
   305  	// empty values are omitted from API requests. However, any non-pointer,
   306  	// non-interface field appearing in ForceSendFields will be sent to the
   307  	// server regardless of whether the field is empty or not. This may be
   308  	// used to include empty fields in Patch requests.
   309  	ForceSendFields []string `json:"-"`
   310  
   311  	// NullFields is a list of field names (e.g. "ActionId") to include in
   312  	// API requests with the JSON null value. By default, fields with empty
   313  	// values are omitted from API requests. However, any field with an
   314  	// empty value appearing in NullFields will be sent to the server as
   315  	// null. It is an error if a field in this list has a non-empty value.
   316  	// This may be used to include null fields in Patch requests.
   317  	NullFields []string `json:"-"`
   318  }
   319  
   320  func (s *ContainerStoppedEvent) MarshalJSON() ([]byte, error) {
   321  	type NoMethod ContainerStoppedEvent
   322  	raw := NoMethod(*s)
   323  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   324  }
   325  
   326  // ControllerConfig: Stores the information that the controller will
   327  // fetch from the server in order to run. Should only be used by VMs
   328  // created by the Pipelines Service and not by end users.
   329  type ControllerConfig struct {
   330  	Cmd string `json:"cmd,omitempty"`
   331  
   332  	Disks map[string]string `json:"disks,omitempty"`
   333  
   334  	GcsLogPath string `json:"gcsLogPath,omitempty"`
   335  
   336  	GcsSinks map[string]RepeatedString `json:"gcsSinks,omitempty"`
   337  
   338  	GcsSources map[string]RepeatedString `json:"gcsSources,omitempty"`
   339  
   340  	Image string `json:"image,omitempty"`
   341  
   342  	MachineType string `json:"machineType,omitempty"`
   343  
   344  	Vars map[string]string `json:"vars,omitempty"`
   345  
   346  	// ServerResponse contains the HTTP response code and headers from the
   347  	// server.
   348  	googleapi.ServerResponse `json:"-"`
   349  
   350  	// ForceSendFields is a list of field names (e.g. "Cmd") to
   351  	// unconditionally include in API requests. By default, fields with
   352  	// empty values are omitted from API requests. However, any non-pointer,
   353  	// non-interface field appearing in ForceSendFields will be sent to the
   354  	// server regardless of whether the field is empty or not. This may be
   355  	// used to include empty fields in Patch requests.
   356  	ForceSendFields []string `json:"-"`
   357  
   358  	// NullFields is a list of field names (e.g. "Cmd") to include in API
   359  	// requests with the JSON null value. By default, fields with empty
   360  	// values are omitted from API requests. However, any field with an
   361  	// empty value appearing in NullFields will be sent to the server as
   362  	// null. It is an error if a field in this list has a non-empty value.
   363  	// This may be used to include null fields in Patch requests.
   364  	NullFields []string `json:"-"`
   365  }
   366  
   367  func (s *ControllerConfig) MarshalJSON() ([]byte, error) {
   368  	type NoMethod ControllerConfig
   369  	raw := NoMethod(*s)
   370  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   371  }
   372  
   373  // DelayedEvent: An event generated whenever a resource limitation or
   374  // transient error delays execution of a pipeline that was otherwise
   375  // ready to run.
   376  type DelayedEvent struct {
   377  	// Cause: A textual description of the cause of the delay. The string
   378  	// can change without notice because it is often generated by another
   379  	// service (such as Compute Engine).
   380  	Cause string `json:"cause,omitempty"`
   381  
   382  	// Metrics: If the delay was caused by a resource shortage, this field
   383  	// lists the Compute Engine metrics that are preventing this operation
   384  	// from running (for example, `CPUS` or `INSTANCES`). If the particular
   385  	// metric is not known, a single `UNKNOWN` metric will be present.
   386  	Metrics []string `json:"metrics,omitempty"`
   387  
   388  	// ForceSendFields is a list of field names (e.g. "Cause") to
   389  	// unconditionally include in API requests. By default, fields with
   390  	// empty values are omitted from API requests. However, any non-pointer,
   391  	// non-interface field appearing in ForceSendFields will be sent to the
   392  	// server regardless of whether the field is empty or not. This may be
   393  	// used to include empty fields in Patch requests.
   394  	ForceSendFields []string `json:"-"`
   395  
   396  	// NullFields is a list of field names (e.g. "Cause") to include in API
   397  	// requests with the JSON null value. By default, fields with empty
   398  	// values are omitted from API requests. However, any field with an
   399  	// empty value appearing in NullFields will be sent to the server as
   400  	// null. It is an error if a field in this list has a non-empty value.
   401  	// This may be used to include null fields in Patch requests.
   402  	NullFields []string `json:"-"`
   403  }
   404  
   405  func (s *DelayedEvent) MarshalJSON() ([]byte, error) {
   406  	type NoMethod DelayedEvent
   407  	raw := NoMethod(*s)
   408  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   409  }
   410  
   411  // Disk: A Google Compute Engine disk resource specification.
   412  type Disk struct {
   413  	// AutoDelete: Deprecated. Disks created by the Pipelines API will be
   414  	// deleted at the end of the pipeline run, regardless of what this field
   415  	// is set to.
   416  	AutoDelete bool `json:"autoDelete,omitempty"`
   417  
   418  	// MountPoint: Required at create time and cannot be overridden at run
   419  	// time. Specifies the path in the docker container where files on this
   420  	// disk should be located. For example, if `mountPoint` is `/mnt/disk`,
   421  	// and the parameter has `localPath` `inputs/file.txt`, the docker
   422  	// container can access the data at `/mnt/disk/inputs/file.txt`.
   423  	MountPoint string `json:"mountPoint,omitempty"`
   424  
   425  	// Name: Required. The name of the disk that can be used in the pipeline
   426  	// parameters. Must be 1 - 63 characters. The name "boot" is reserved
   427  	// for system use.
   428  	Name string `json:"name,omitempty"`
   429  
   430  	// ReadOnly: Specifies how a sourced-base persistent disk will be
   431  	// mounted. See
   432  	// https://cloud.google.com/compute/docs/disks/persistent-disks#use_multi_instances
   433  	// for more details. Can only be set at create time.
   434  	ReadOnly bool `json:"readOnly,omitempty"`
   435  
   436  	// SizeGb: The size of the disk. Defaults to 500 (GB). This field is not
   437  	// applicable for local SSD.
   438  	SizeGb int64 `json:"sizeGb,omitempty"`
   439  
   440  	// Source: The full or partial URL of the persistent disk to attach. See
   441  	// https://cloud.google.com/compute/docs/reference/latest/instances#resource
   442  	// and
   443  	// https://cloud.google.com/compute/docs/disks/persistent-disks#snapshots
   444  	// for more details.
   445  	Source string `json:"source,omitempty"`
   446  
   447  	// Type: Required. The type of the disk to create.
   448  	//
   449  	// Possible values:
   450  	//   "TYPE_UNSPECIFIED" - Default disk type. Use one of the other
   451  	// options below.
   452  	//   "PERSISTENT_HDD" - Specifies a Google Compute Engine persistent
   453  	// hard disk. See https://cloud.google.com/compute/docs/disks/#pdspecs
   454  	// for details.
   455  	//   "PERSISTENT_SSD" - Specifies a Google Compute Engine persistent
   456  	// solid-state disk. See
   457  	// https://cloud.google.com/compute/docs/disks/#pdspecs for details.
   458  	//   "LOCAL_SSD" - Specifies a Google Compute Engine local SSD. See
   459  	// https://cloud.google.com/compute/docs/disks/local-ssd for details.
   460  	Type string `json:"type,omitempty"`
   461  
   462  	// ForceSendFields is a list of field names (e.g. "AutoDelete") to
   463  	// unconditionally include in API requests. By default, fields with
   464  	// empty values are omitted from API requests. However, any non-pointer,
   465  	// non-interface field appearing in ForceSendFields will be sent to the
   466  	// server regardless of whether the field is empty or not. This may be
   467  	// used to include empty fields in Patch requests.
   468  	ForceSendFields []string `json:"-"`
   469  
   470  	// NullFields is a list of field names (e.g. "AutoDelete") to include in
   471  	// API requests with the JSON null value. By default, fields with empty
   472  	// values are omitted from API requests. However, any field with an
   473  	// empty value appearing in NullFields will be sent to the server as
   474  	// null. It is an error if a field in this list has a non-empty value.
   475  	// This may be used to include null fields in Patch requests.
   476  	NullFields []string `json:"-"`
   477  }
   478  
   479  func (s *Disk) MarshalJSON() ([]byte, error) {
   480  	type NoMethod Disk
   481  	raw := NoMethod(*s)
   482  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   483  }
   484  
   485  // DockerExecutor: The Docker execuctor specification.
   486  type DockerExecutor struct {
   487  	// Cmd: Required. The command or newline delimited script to run. The
   488  	// command string will be executed within a bash shell. If the command
   489  	// exits with a non-zero exit code, output parameter de-localization
   490  	// will be skipped and the pipeline operation's `error` field will be
   491  	// populated. Maximum command string length is 16384.
   492  	Cmd string `json:"cmd,omitempty"`
   493  
   494  	// ImageName: Required. Image name from either Docker Hub or Google
   495  	// Container Registry. Users that run pipelines must have READ access to
   496  	// the image.
   497  	ImageName string `json:"imageName,omitempty"`
   498  
   499  	// ForceSendFields is a list of field names (e.g. "Cmd") to
   500  	// unconditionally include in API requests. By default, fields with
   501  	// empty values are omitted from API requests. However, any non-pointer,
   502  	// non-interface field appearing in ForceSendFields will be sent to the
   503  	// server regardless of whether the field is empty or not. This may be
   504  	// used to include empty fields in Patch requests.
   505  	ForceSendFields []string `json:"-"`
   506  
   507  	// NullFields is a list of field names (e.g. "Cmd") to include in API
   508  	// requests with the JSON null value. By default, fields with empty
   509  	// values are omitted from API requests. However, any field with an
   510  	// empty value appearing in NullFields will be sent to the server as
   511  	// null. It is an error if a field in this list has a non-empty value.
   512  	// This may be used to include null fields in Patch requests.
   513  	NullFields []string `json:"-"`
   514  }
   515  
   516  func (s *DockerExecutor) MarshalJSON() ([]byte, error) {
   517  	type NoMethod DockerExecutor
   518  	raw := NoMethod(*s)
   519  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   520  }
   521  
   522  // Empty: A generic empty message that you can re-use to avoid defining
   523  // duplicated empty messages in your APIs. A typical example is to use
   524  // it as the request or the response type of an API method. For
   525  // instance: service Foo { rpc Bar(google.protobuf.Empty) returns
   526  // (google.protobuf.Empty); } The JSON representation for `Empty` is
   527  // empty JSON object `{}`.
   528  type Empty struct {
   529  	// ServerResponse contains the HTTP response code and headers from the
   530  	// server.
   531  	googleapi.ServerResponse `json:"-"`
   532  }
   533  
   534  // Event: Carries information about events that occur during pipeline
   535  // execution.
   536  type Event struct {
   537  	// Description: A human-readable description of the event. Note that
   538  	// these strings can change at any time without notice. Any application
   539  	// logic must use the information in the `details` field.
   540  	Description string `json:"description,omitempty"`
   541  
   542  	// Details: Machine-readable details about the event.
   543  	Details googleapi.RawMessage `json:"details,omitempty"`
   544  
   545  	// Timestamp: The time at which the event occurred.
   546  	Timestamp string `json:"timestamp,omitempty"`
   547  
   548  	// ForceSendFields is a list of field names (e.g. "Description") to
   549  	// unconditionally include in API requests. By default, fields with
   550  	// empty values are omitted from API requests. However, any non-pointer,
   551  	// non-interface field appearing in ForceSendFields will be sent to the
   552  	// server regardless of whether the field is empty or not. This may be
   553  	// used to include empty fields in Patch requests.
   554  	ForceSendFields []string `json:"-"`
   555  
   556  	// NullFields is a list of field names (e.g. "Description") to include
   557  	// in API requests with the JSON null value. By default, fields with
   558  	// empty values are omitted from API requests. However, any field with
   559  	// an empty value appearing in NullFields will be sent to the server as
   560  	// null. It is an error if a field in this list has a non-empty value.
   561  	// This may be used to include null fields in Patch requests.
   562  	NullFields []string `json:"-"`
   563  }
   564  
   565  func (s *Event) MarshalJSON() ([]byte, error) {
   566  	type NoMethod Event
   567  	raw := NoMethod(*s)
   568  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   569  }
   570  
   571  // FailedEvent: An event generated when the execution of a pipeline has
   572  // failed. Note that other events can continue to occur after this
   573  // event.
   574  type FailedEvent struct {
   575  	// Cause: The human-readable description of the cause of the failure.
   576  	Cause string `json:"cause,omitempty"`
   577  
   578  	// Code: The Google standard error code that best describes this
   579  	// failure.
   580  	//
   581  	// Possible values:
   582  	//   "OK" - Not an error; returned on success HTTP Mapping: 200 OK
   583  	//   "CANCELLED" - The operation was cancelled, typically by the caller.
   584  	// HTTP Mapping: 499 Client Closed Request
   585  	//   "UNKNOWN" - Unknown error. For example, this error may be returned
   586  	// when a `Status` value received from another address space belongs to
   587  	// an error space that is not known in this address space. Also errors
   588  	// raised by APIs that do not return enough error information may be
   589  	// converted to this error. HTTP Mapping: 500 Internal Server Error
   590  	//   "INVALID_ARGUMENT" - The client specified an invalid argument. Note
   591  	// that this differs from `FAILED_PRECONDITION`. `INVALID_ARGUMENT`
   592  	// indicates arguments that are problematic regardless of the state of
   593  	// the system (e.g., a malformed file name). HTTP Mapping: 400 Bad
   594  	// Request
   595  	//   "DEADLINE_EXCEEDED" - The deadline expired before the operation
   596  	// could complete. For operations that change the state of the system,
   597  	// this error may be returned even if the operation has completed
   598  	// successfully. For example, a successful response from a server could
   599  	// have been delayed long enough for the deadline to expire. HTTP
   600  	// Mapping: 504 Gateway Timeout
   601  	//   "NOT_FOUND" - Some requested entity (e.g., file or directory) was
   602  	// not found. Note to server developers: if a request is denied for an
   603  	// entire class of users, such as gradual feature rollout or
   604  	// undocumented allowlist, `NOT_FOUND` may be used. If a request is
   605  	// denied for some users within a class of users, such as user-based
   606  	// access control, `PERMISSION_DENIED` must be used. HTTP Mapping: 404
   607  	// Not Found
   608  	//   "ALREADY_EXISTS" - The entity that a client attempted to create
   609  	// (e.g., file or directory) already exists. HTTP Mapping: 409 Conflict
   610  	//   "PERMISSION_DENIED" - The caller does not have permission to
   611  	// execute the specified operation. `PERMISSION_DENIED` must not be used
   612  	// for rejections caused by exhausting some resource (use
   613  	// `RESOURCE_EXHAUSTED` instead for those errors). `PERMISSION_DENIED`
   614  	// must not be used if the caller can not be identified (use
   615  	// `UNAUTHENTICATED` instead for those errors). This error code does not
   616  	// imply the request is valid or the requested entity exists or
   617  	// satisfies other pre-conditions. HTTP Mapping: 403 Forbidden
   618  	//   "UNAUTHENTICATED" - The request does not have valid authentication
   619  	// credentials for the operation. HTTP Mapping: 401 Unauthorized
   620  	//   "RESOURCE_EXHAUSTED" - Some resource has been exhausted, perhaps a
   621  	// per-user quota, or perhaps the entire file system is out of space.
   622  	// HTTP Mapping: 429 Too Many Requests
   623  	//   "FAILED_PRECONDITION" - The operation was rejected because the
   624  	// system is not in a state required for the operation's execution. For
   625  	// example, the directory to be deleted is non-empty, an rmdir operation
   626  	// is applied to a non-directory, etc. Service implementors can use the
   627  	// following guidelines to decide between `FAILED_PRECONDITION`,
   628  	// `ABORTED`, and `UNAVAILABLE`: (a) Use `UNAVAILABLE` if the client can
   629  	// retry just the failing call. (b) Use `ABORTED` if the client should
   630  	// retry at a higher level. For example, when a client-specified
   631  	// test-and-set fails, indicating the client should restart a
   632  	// read-modify-write sequence. (c) Use `FAILED_PRECONDITION` if the
   633  	// client should not retry until the system state has been explicitly
   634  	// fixed. For example, if an "rmdir" fails because the directory is
   635  	// non-empty, `FAILED_PRECONDITION` should be returned since the client
   636  	// should not retry unless the files are deleted from the directory.
   637  	// HTTP Mapping: 400 Bad Request
   638  	//   "ABORTED" - The operation was aborted, typically due to a
   639  	// concurrency issue such as a sequencer check failure or transaction
   640  	// abort. See the guidelines above for deciding between
   641  	// `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`. HTTP Mapping:
   642  	// 409 Conflict
   643  	//   "OUT_OF_RANGE" - The operation was attempted past the valid range.
   644  	// E.g., seeking or reading past end-of-file. Unlike `INVALID_ARGUMENT`,
   645  	// this error indicates a problem that may be fixed if the system state
   646  	// changes. For example, a 32-bit file system will generate
   647  	// `INVALID_ARGUMENT` if asked to read at an offset that is not in the
   648  	// range [0,2^32-1], but it will generate `OUT_OF_RANGE` if asked to
   649  	// read from an offset past the current file size. There is a fair bit
   650  	// of overlap between `FAILED_PRECONDITION` and `OUT_OF_RANGE`. We
   651  	// recommend using `OUT_OF_RANGE` (the more specific error) when it
   652  	// applies so that callers who are iterating through a space can easily
   653  	// look for an `OUT_OF_RANGE` error to detect when they are done. HTTP
   654  	// Mapping: 400 Bad Request
   655  	//   "UNIMPLEMENTED" - The operation is not implemented or is not
   656  	// supported/enabled in this service. HTTP Mapping: 501 Not Implemented
   657  	//   "INTERNAL" - Internal errors. This means that some invariants
   658  	// expected by the underlying system have been broken. This error code
   659  	// is reserved for serious errors. HTTP Mapping: 500 Internal Server
   660  	// Error
   661  	//   "UNAVAILABLE" - The service is currently unavailable. This is most
   662  	// likely a transient condition, which can be corrected by retrying with
   663  	// a backoff. Note that it is not always safe to retry non-idempotent
   664  	// operations. See the guidelines above for deciding between
   665  	// `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`. HTTP Mapping:
   666  	// 503 Service Unavailable
   667  	//   "DATA_LOSS" - Unrecoverable data loss or corruption. HTTP Mapping:
   668  	// 500 Internal Server Error
   669  	Code string `json:"code,omitempty"`
   670  
   671  	// ForceSendFields is a list of field names (e.g. "Cause") to
   672  	// unconditionally include in API requests. By default, fields with
   673  	// empty values are omitted from API requests. However, any non-pointer,
   674  	// non-interface field appearing in ForceSendFields will be sent to the
   675  	// server regardless of whether the field is empty or not. This may be
   676  	// used to include empty fields in Patch requests.
   677  	ForceSendFields []string `json:"-"`
   678  
   679  	// NullFields is a list of field names (e.g. "Cause") to include in API
   680  	// requests with the JSON null value. By default, fields with empty
   681  	// values are omitted from API requests. However, any field with an
   682  	// empty value appearing in NullFields will be sent to the server as
   683  	// null. It is an error if a field in this list has a non-empty value.
   684  	// This may be used to include null fields in Patch requests.
   685  	NullFields []string `json:"-"`
   686  }
   687  
   688  func (s *FailedEvent) MarshalJSON() ([]byte, error) {
   689  	type NoMethod FailedEvent
   690  	raw := NoMethod(*s)
   691  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   692  }
   693  
   694  // ListOperationsResponse: The response message for
   695  // Operations.ListOperations.
   696  type ListOperationsResponse struct {
   697  	// NextPageToken: The standard List next-page token.
   698  	NextPageToken string `json:"nextPageToken,omitempty"`
   699  
   700  	// Operations: A list of operations that matches the specified filter in
   701  	// the request.
   702  	Operations []*Operation `json:"operations,omitempty"`
   703  
   704  	// ServerResponse contains the HTTP response code and headers from the
   705  	// server.
   706  	googleapi.ServerResponse `json:"-"`
   707  
   708  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
   709  	// unconditionally include in API requests. By default, fields with
   710  	// empty values are omitted from API requests. However, any non-pointer,
   711  	// non-interface field appearing in ForceSendFields will be sent to the
   712  	// server regardless of whether the field is empty or not. This may be
   713  	// used to include empty fields in Patch requests.
   714  	ForceSendFields []string `json:"-"`
   715  
   716  	// NullFields is a list of field names (e.g. "NextPageToken") to include
   717  	// in API requests with the JSON null value. By default, fields with
   718  	// empty values are omitted from API requests. However, any field with
   719  	// an empty value appearing in NullFields will be sent to the server as
   720  	// null. It is an error if a field in this list has a non-empty value.
   721  	// This may be used to include null fields in Patch requests.
   722  	NullFields []string `json:"-"`
   723  }
   724  
   725  func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) {
   726  	type NoMethod ListOperationsResponse
   727  	raw := NoMethod(*s)
   728  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   729  }
   730  
   731  // ListPipelinesResponse: The response of ListPipelines. Contains at
   732  // most `pageSize` pipelines. If it contains `pageSize` pipelines, and
   733  // more pipelines exist, then `nextPageToken` will be populated and
   734  // should be used as the `pageToken` argument to a subsequent
   735  // ListPipelines request.
   736  type ListPipelinesResponse struct {
   737  	// NextPageToken: The token to use to get the next page of results.
   738  	NextPageToken string `json:"nextPageToken,omitempty"`
   739  
   740  	// Pipelines: The matched pipelines.
   741  	Pipelines []*Pipeline `json:"pipelines,omitempty"`
   742  
   743  	// ServerResponse contains the HTTP response code and headers from the
   744  	// server.
   745  	googleapi.ServerResponse `json:"-"`
   746  
   747  	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
   748  	// unconditionally include in API requests. By default, fields with
   749  	// empty values are omitted from API requests. However, any non-pointer,
   750  	// non-interface field appearing in ForceSendFields will be sent to the
   751  	// server regardless of whether the field is empty or not. This may be
   752  	// used to include empty fields in Patch requests.
   753  	ForceSendFields []string `json:"-"`
   754  
   755  	// NullFields is a list of field names (e.g. "NextPageToken") to include
   756  	// in API requests with the JSON null value. By default, fields with
   757  	// empty values are omitted from API requests. However, any field with
   758  	// an empty value appearing in NullFields will be sent to the server as
   759  	// null. It is an error if a field in this list has a non-empty value.
   760  	// This may be used to include null fields in Patch requests.
   761  	NullFields []string `json:"-"`
   762  }
   763  
   764  func (s *ListPipelinesResponse) MarshalJSON() ([]byte, error) {
   765  	type NoMethod ListPipelinesResponse
   766  	raw := NoMethod(*s)
   767  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   768  }
   769  
   770  // LocalCopy: LocalCopy defines how a remote file should be copied to
   771  // and from the VM.
   772  type LocalCopy struct {
   773  	// Disk: Required. The name of the disk where this parameter is located.
   774  	// Can be the name of one of the disks specified in the Resources field,
   775  	// or "boot", which represents the Docker instance's boot disk and has a
   776  	// mount point of `/`.
   777  	Disk string `json:"disk,omitempty"`
   778  
   779  	// Path: Required. The path within the user's docker container where
   780  	// this input should be localized to and from, relative to the specified
   781  	// disk's mount point. For example: file.txt,
   782  	Path string `json:"path,omitempty"`
   783  
   784  	// ForceSendFields is a list of field names (e.g. "Disk") to
   785  	// unconditionally include in API requests. By default, fields with
   786  	// empty values are omitted from API requests. However, any non-pointer,
   787  	// non-interface field appearing in ForceSendFields will be sent to the
   788  	// server regardless of whether the field is empty or not. This may be
   789  	// used to include empty fields in Patch requests.
   790  	ForceSendFields []string `json:"-"`
   791  
   792  	// NullFields is a list of field names (e.g. "Disk") to include in API
   793  	// requests with the JSON null value. By default, fields with empty
   794  	// values are omitted from API requests. However, any field with an
   795  	// empty value appearing in NullFields will be sent to the server as
   796  	// null. It is an error if a field in this list has a non-empty value.
   797  	// This may be used to include null fields in Patch requests.
   798  	NullFields []string `json:"-"`
   799  }
   800  
   801  func (s *LocalCopy) MarshalJSON() ([]byte, error) {
   802  	type NoMethod LocalCopy
   803  	raw := NoMethod(*s)
   804  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   805  }
   806  
   807  // LoggingOptions: The logging options for the pipeline run.
   808  type LoggingOptions struct {
   809  	// GcsPath: The location in Google Cloud Storage to which the pipeline
   810  	// logs will be copied. Can be specified as a fully qualified directory
   811  	// path, in which case logs will be output with a unique identifier as
   812  	// the filename in that directory, or as a fully specified path, which
   813  	// must end in `.log`, in which case that path will be used, and the
   814  	// user must ensure that logs are not overwritten. Stdout and stderr
   815  	// logs from the run are also generated and output as `-stdout.log` and
   816  	// `-stderr.log`.
   817  	GcsPath string `json:"gcsPath,omitempty"`
   818  
   819  	// ForceSendFields is a list of field names (e.g. "GcsPath") to
   820  	// unconditionally include in API requests. By default, fields with
   821  	// empty values are omitted from API requests. However, any non-pointer,
   822  	// non-interface field appearing in ForceSendFields will be sent to the
   823  	// server regardless of whether the field is empty or not. This may be
   824  	// used to include empty fields in Patch requests.
   825  	ForceSendFields []string `json:"-"`
   826  
   827  	// NullFields is a list of field names (e.g. "GcsPath") to include in
   828  	// API requests with the JSON null value. By default, fields with empty
   829  	// values are omitted from API requests. However, any field with an
   830  	// empty value appearing in NullFields will be sent to the server as
   831  	// null. It is an error if a field in this list has a non-empty value.
   832  	// This may be used to include null fields in Patch requests.
   833  	NullFields []string `json:"-"`
   834  }
   835  
   836  func (s *LoggingOptions) MarshalJSON() ([]byte, error) {
   837  	type NoMethod LoggingOptions
   838  	raw := NoMethod(*s)
   839  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   840  }
   841  
   842  // Operation: This resource represents a long-running operation that is
   843  // the result of a network API call.
   844  type Operation struct {
   845  	// Done: If the value is `false`, it means the operation is still in
   846  	// progress. If `true`, the operation is completed, and either `error`
   847  	// or `response` is available.
   848  	Done bool `json:"done,omitempty"`
   849  
   850  	// Error: The error result of the operation in case of failure or
   851  	// cancellation.
   852  	Error *Status `json:"error,omitempty"`
   853  
   854  	// Metadata: An OperationMetadata or Metadata object. This will always
   855  	// be returned with the Operation.
   856  	Metadata googleapi.RawMessage `json:"metadata,omitempty"`
   857  
   858  	// Name: The server-assigned name, which is only unique within the same
   859  	// service that originally returns it. For example:
   860  	// `operations/CJHU7Oi_ChDrveSpBRjfuL-qzoWAgEw`
   861  	Name string `json:"name,omitempty"`
   862  
   863  	// Response: An Empty object.
   864  	Response googleapi.RawMessage `json:"response,omitempty"`
   865  
   866  	// ServerResponse contains the HTTP response code and headers from the
   867  	// server.
   868  	googleapi.ServerResponse `json:"-"`
   869  
   870  	// ForceSendFields is a list of field names (e.g. "Done") to
   871  	// unconditionally include in API requests. By default, fields with
   872  	// empty values are omitted from API requests. However, any non-pointer,
   873  	// non-interface field appearing in ForceSendFields will be sent to the
   874  	// server regardless of whether the field is empty or not. This may be
   875  	// used to include empty fields in Patch requests.
   876  	ForceSendFields []string `json:"-"`
   877  
   878  	// NullFields is a list of field names (e.g. "Done") to include in API
   879  	// requests with the JSON null value. By default, fields with empty
   880  	// values are omitted from API requests. However, any field with an
   881  	// empty value appearing in NullFields will be sent to the server as
   882  	// null. It is an error if a field in this list has a non-empty value.
   883  	// This may be used to include null fields in Patch requests.
   884  	NullFields []string `json:"-"`
   885  }
   886  
   887  func (s *Operation) MarshalJSON() ([]byte, error) {
   888  	type NoMethod Operation
   889  	raw := NoMethod(*s)
   890  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   891  }
   892  
   893  // OperationEvent: An event that occurred during an Operation.
   894  type OperationEvent struct {
   895  	// Description: Required description of event.
   896  	Description string `json:"description,omitempty"`
   897  
   898  	// EndTime: Optional time of when event finished. An event can have a
   899  	// start time and no finish time. If an event has a finish time, there
   900  	// must be a start time.
   901  	EndTime string `json:"endTime,omitempty"`
   902  
   903  	// StartTime: Optional time of when event started.
   904  	StartTime string `json:"startTime,omitempty"`
   905  
   906  	// ForceSendFields is a list of field names (e.g. "Description") to
   907  	// unconditionally include in API requests. By default, fields with
   908  	// empty values are omitted from API requests. However, any non-pointer,
   909  	// non-interface field appearing in ForceSendFields will be sent to the
   910  	// server regardless of whether the field is empty or not. This may be
   911  	// used to include empty fields in Patch requests.
   912  	ForceSendFields []string `json:"-"`
   913  
   914  	// NullFields is a list of field names (e.g. "Description") to include
   915  	// in API requests with the JSON null value. By default, fields with
   916  	// empty values are omitted from API requests. However, any field with
   917  	// an empty value appearing in NullFields will be sent to the server as
   918  	// null. It is an error if a field in this list has a non-empty value.
   919  	// This may be used to include null fields in Patch requests.
   920  	NullFields []string `json:"-"`
   921  }
   922  
   923  func (s *OperationEvent) MarshalJSON() ([]byte, error) {
   924  	type NoMethod OperationEvent
   925  	raw := NoMethod(*s)
   926  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   927  }
   928  
   929  // OperationMetadata: Metadata describing an Operation.
   930  type OperationMetadata struct {
   931  	// ClientId: This field is deprecated. Use `labels` instead. Optionally
   932  	// provided by the caller when submitting the request that creates the
   933  	// operation.
   934  	ClientId string `json:"clientId,omitempty"`
   935  
   936  	// CreateTime: The time at which the job was submitted to the Genomics
   937  	// service.
   938  	CreateTime string `json:"createTime,omitempty"`
   939  
   940  	// EndTime: The time at which the job stopped running.
   941  	EndTime string `json:"endTime,omitempty"`
   942  
   943  	// Events: Optional event messages that were generated during the job's
   944  	// execution. This also contains any warnings that were generated during
   945  	// import or export.
   946  	Events []*OperationEvent `json:"events,omitempty"`
   947  
   948  	// Labels: Optionally provided by the caller when submitting the request
   949  	// that creates the operation.
   950  	Labels map[string]string `json:"labels,omitempty"`
   951  
   952  	// ProjectId: The Google Cloud Project in which the job is scoped.
   953  	ProjectId string `json:"projectId,omitempty"`
   954  
   955  	// Request: The original request that started the operation. Note that
   956  	// this will be in current version of the API. If the operation was
   957  	// started with v1beta2 API and a GetOperation is performed on v1 API, a
   958  	// v1 request will be returned.
   959  	Request googleapi.RawMessage `json:"request,omitempty"`
   960  
   961  	// RuntimeMetadata: Runtime metadata on this Operation.
   962  	RuntimeMetadata googleapi.RawMessage `json:"runtimeMetadata,omitempty"`
   963  
   964  	// StartTime: The time at which the job began to run.
   965  	StartTime string `json:"startTime,omitempty"`
   966  
   967  	// ForceSendFields is a list of field names (e.g. "ClientId") to
   968  	// unconditionally include in API requests. By default, fields with
   969  	// empty values are omitted from API requests. However, any non-pointer,
   970  	// non-interface field appearing in ForceSendFields will be sent to the
   971  	// server regardless of whether the field is empty or not. This may be
   972  	// used to include empty fields in Patch requests.
   973  	ForceSendFields []string `json:"-"`
   974  
   975  	// NullFields is a list of field names (e.g. "ClientId") to include in
   976  	// API requests with the JSON null value. By default, fields with empty
   977  	// values are omitted from API requests. However, any field with an
   978  	// empty value appearing in NullFields will be sent to the server as
   979  	// null. It is an error if a field in this list has a non-empty value.
   980  	// This may be used to include null fields in Patch requests.
   981  	NullFields []string `json:"-"`
   982  }
   983  
   984  func (s *OperationMetadata) MarshalJSON() ([]byte, error) {
   985  	type NoMethod OperationMetadata
   986  	raw := NoMethod(*s)
   987  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   988  }
   989  
   990  // Pipeline: The pipeline object. Represents a transformation from a set
   991  // of input parameters to a set of output parameters. The transformation
   992  // is defined as a docker image and command to run within that image.
   993  // Each pipeline is run on a Google Compute Engine VM. A pipeline can be
   994  // created with the `create` method and then later run with the `run`
   995  // method, or a pipeline can be defined and run all at once with the
   996  // `run` method.
   997  type Pipeline struct {
   998  	// Description: User-specified description.
   999  	Description string `json:"description,omitempty"`
  1000  
  1001  	// Docker: Specifies the docker run information.
  1002  	Docker *DockerExecutor `json:"docker,omitempty"`
  1003  
  1004  	// InputParameters: Input parameters of the pipeline.
  1005  	InputParameters []*PipelineParameter `json:"inputParameters,omitempty"`
  1006  
  1007  	// Name: Required. A user specified pipeline name that does not have to
  1008  	// be unique. This name can be used for filtering Pipelines in
  1009  	// ListPipelines.
  1010  	Name string `json:"name,omitempty"`
  1011  
  1012  	// OutputParameters: Output parameters of the pipeline.
  1013  	OutputParameters []*PipelineParameter `json:"outputParameters,omitempty"`
  1014  
  1015  	// PipelineId: Unique pipeline id that is generated by the service when
  1016  	// CreatePipeline is called. Cannot be specified in the Pipeline used in
  1017  	// the CreatePipelineRequest, and will be populated in the response to
  1018  	// CreatePipeline and all subsequent Get and List calls. Indicates that
  1019  	// the service has registered this pipeline.
  1020  	PipelineId string `json:"pipelineId,omitempty"`
  1021  
  1022  	// ProjectId: Required. The project in which to create the pipeline. The
  1023  	// caller must have WRITE access.
  1024  	ProjectId string `json:"projectId,omitempty"`
  1025  
  1026  	// Resources: Required. Specifies resource requirements for the pipeline
  1027  	// run. Required fields: * minimumCpuCores * minimumRamGb
  1028  	Resources *PipelineResources `json:"resources,omitempty"`
  1029  
  1030  	// ServerResponse contains the HTTP response code and headers from the
  1031  	// server.
  1032  	googleapi.ServerResponse `json:"-"`
  1033  
  1034  	// ForceSendFields is a list of field names (e.g. "Description") to
  1035  	// unconditionally include in API requests. By default, fields with
  1036  	// empty values are omitted from API requests. However, any non-pointer,
  1037  	// non-interface field appearing in ForceSendFields will be sent to the
  1038  	// server regardless of whether the field is empty or not. This may be
  1039  	// used to include empty fields in Patch requests.
  1040  	ForceSendFields []string `json:"-"`
  1041  
  1042  	// NullFields is a list of field names (e.g. "Description") to include
  1043  	// in API requests with the JSON null value. By default, fields with
  1044  	// empty values are omitted from API requests. However, any field with
  1045  	// an empty value appearing in NullFields will be sent to the server as
  1046  	// null. It is an error if a field in this list has a non-empty value.
  1047  	// This may be used to include null fields in Patch requests.
  1048  	NullFields []string `json:"-"`
  1049  }
  1050  
  1051  func (s *Pipeline) MarshalJSON() ([]byte, error) {
  1052  	type NoMethod Pipeline
  1053  	raw := NoMethod(*s)
  1054  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1055  }
  1056  
  1057  // PipelineParameter: Parameters facilitate setting and delivering data
  1058  // into the pipeline's execution environment. They are defined at create
  1059  // time, with optional defaults, and can be overridden at run time. If
  1060  // `localCopy` is unset, then the parameter specifies a string that is
  1061  // passed as-is into the pipeline, as the value of the environment
  1062  // variable with the given name. A default value can be optionally
  1063  // specified at create time. The default can be overridden at run time
  1064  // using the inputs map. If no default is given, a value must be
  1065  // supplied at runtime. If `localCopy` is defined, then the parameter
  1066  // specifies a data source or sink, both in Google Cloud Storage and on
  1067  // the Docker container where the pipeline computation is run. The
  1068  // service account associated with the Pipeline (by default the
  1069  // project's Compute Engine service account) must have access to the
  1070  // Google Cloud Storage paths. At run time, the Google Cloud Storage
  1071  // paths can be overridden if a default was provided at create time, or
  1072  // must be set otherwise. The pipeline runner should add a key/value
  1073  // pair to either the inputs or outputs map. The indicated data copies
  1074  // will be carried out before/after pipeline execution, just as if the
  1075  // corresponding arguments were provided to `gsutil cp`. For example:
  1076  // Given the following `PipelineParameter`, specified in the
  1077  // `inputParameters` list: ``` {name: "input_file", localCopy: {path:
  1078  // "file.txt", disk: "pd1"}} ``` where `disk` is defined in the
  1079  // `PipelineResources` object as: ``` {name: "pd1", mountPoint:
  1080  // "/mnt/disk/"} ``` We create a disk named `pd1`, mount it on the host
  1081  // VM, and map `/mnt/pd1` to `/mnt/disk` in the docker container. At
  1082  // runtime, an entry for `input_file` would be required in the inputs
  1083  // map, such as: ``` inputs["input_file"] = "gs://my-bucket/bar.txt" ```
  1084  // This would generate the following gsutil call: ``` gsutil cp
  1085  // gs://my-bucket/bar.txt /mnt/pd1/file.txt ``` The file
  1086  // `/mnt/pd1/file.txt` maps to `/mnt/disk/file.txt` in the Docker
  1087  // container. Acceptable paths are: Google Cloud storage pathLocal path
  1088  // file file glob directory For outputs, the direction of the copy is
  1089  // reversed: ``` gsutil cp /mnt/disk/file.txt gs://my-bucket/bar.txt ```
  1090  // Acceptable paths are: Local pathGoogle Cloud Storage path file file
  1091  // file directory - directory must already exist glob directory -
  1092  // directory will be created if it doesn't exist One restriction due to
  1093  // docker limitations, is that for outputs that are found on the boot
  1094  // disk, the local path cannot be a glob and must be a file.
  1095  type PipelineParameter struct {
  1096  	// DefaultValue: The default value for this parameter. Can be overridden
  1097  	// at runtime. If `localCopy` is present, then this must be a Google
  1098  	// Cloud Storage path beginning with `gs://`.
  1099  	DefaultValue string `json:"defaultValue,omitempty"`
  1100  
  1101  	// Description: Human-readable description.
  1102  	Description string `json:"description,omitempty"`
  1103  
  1104  	// LocalCopy: If present, this parameter is marked for copying to and
  1105  	// from the VM. `LocalCopy` indicates where on the VM the file should
  1106  	// be. The value given to this parameter (either at runtime or using
  1107  	// `defaultValue`) must be the remote path where the file should be.
  1108  	LocalCopy *LocalCopy `json:"localCopy,omitempty"`
  1109  
  1110  	// Name: Required. Name of the parameter - the pipeline runner uses this
  1111  	// string as the key to the input and output maps in RunPipeline.
  1112  	Name string `json:"name,omitempty"`
  1113  
  1114  	// ForceSendFields is a list of field names (e.g. "DefaultValue") to
  1115  	// unconditionally include in API requests. By default, fields with
  1116  	// empty values are omitted from API requests. However, any non-pointer,
  1117  	// non-interface field appearing in ForceSendFields will be sent to the
  1118  	// server regardless of whether the field is empty or not. This may be
  1119  	// used to include empty fields in Patch requests.
  1120  	ForceSendFields []string `json:"-"`
  1121  
  1122  	// NullFields is a list of field names (e.g. "DefaultValue") to include
  1123  	// in API requests with the JSON null value. By default, fields with
  1124  	// empty values are omitted from API requests. However, any field with
  1125  	// an empty value appearing in NullFields will be sent to the server as
  1126  	// null. It is an error if a field in this list has a non-empty value.
  1127  	// This may be used to include null fields in Patch requests.
  1128  	NullFields []string `json:"-"`
  1129  }
  1130  
  1131  func (s *PipelineParameter) MarshalJSON() ([]byte, error) {
  1132  	type NoMethod PipelineParameter
  1133  	raw := NoMethod(*s)
  1134  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1135  }
  1136  
  1137  // PipelineResources: The system resources for the pipeline run.
  1138  type PipelineResources struct {
  1139  	// AcceleratorCount: Optional. The number of accelerators of the
  1140  	// specified type to attach. By specifying this parameter, you will
  1141  	// download and install the following third-party software onto your
  1142  	// managed Compute Engine instances: NVIDIA® Tesla® drivers and
  1143  	// NVIDIA® CUDA toolkit.
  1144  	AcceleratorCount int64 `json:"acceleratorCount,omitempty,string"`
  1145  
  1146  	// AcceleratorType: Optional. The Compute Engine defined accelerator
  1147  	// type. By specifying this parameter, you will download and install the
  1148  	// following third-party software onto your managed Compute Engine
  1149  	// instances: NVIDIA® Tesla® drivers and NVIDIA® CUDA toolkit. Please
  1150  	// see https://cloud.google.com/compute/docs/gpus/ for a list of
  1151  	// available accelerator types.
  1152  	AcceleratorType string `json:"acceleratorType,omitempty"`
  1153  
  1154  	// BootDiskSizeGb: The size of the boot disk. Defaults to 10 (GB).
  1155  	BootDiskSizeGb int64 `json:"bootDiskSizeGb,omitempty"`
  1156  
  1157  	// Disks: Disks to attach.
  1158  	Disks []*Disk `json:"disks,omitempty"`
  1159  
  1160  	// MinimumCpuCores: The minimum number of cores to use. Defaults to 1.
  1161  	MinimumCpuCores int64 `json:"minimumCpuCores,omitempty"`
  1162  
  1163  	// MinimumRamGb: The minimum amount of RAM to use. Defaults to 3.75 (GB)
  1164  	MinimumRamGb float64 `json:"minimumRamGb,omitempty"`
  1165  
  1166  	// NoAddress: Whether to assign an external IP to the instance. This is
  1167  	// an experimental feature that may go away. Defaults to false.
  1168  	// Corresponds to `--no_address` flag for [gcloud compute instances
  1169  	// create]
  1170  	// (https://cloud.google.com/sdk/gcloud/reference/compute/instances/create).
  1171  	// In order to use this, must be true for both create time and run time.
  1172  	// Cannot be true at run time if false at create time. If you need to
  1173  	// ssh into a private IP VM for debugging, you can ssh to a public VM
  1174  	// and then ssh into the private VM's Internal IP. If noAddress is set,
  1175  	// this pipeline run may only load docker images from Google Container
  1176  	// Registry and not Docker Hub. Before using this, you must configure
  1177  	// access to Google services from internal IPs
  1178  	// (https://cloud.google.com/compute/docs/configure-private-google-access#configuring_access_to_google_services_from_internal_ips).
  1179  	NoAddress bool `json:"noAddress,omitempty"`
  1180  
  1181  	// Preemptible: Whether to use preemptible VMs. Defaults to `false`. In
  1182  	// order to use this, must be true for both create time and run time.
  1183  	// Cannot be true at run time if false at create time.
  1184  	Preemptible bool `json:"preemptible,omitempty"`
  1185  
  1186  	// Zones: List of Google Compute Engine availability zones to which
  1187  	// resource creation will restricted. If empty, any zone may be chosen.
  1188  	Zones []string `json:"zones,omitempty"`
  1189  
  1190  	// ForceSendFields is a list of field names (e.g. "AcceleratorCount") to
  1191  	// unconditionally include in API requests. By default, fields with
  1192  	// empty values are omitted from API requests. However, any non-pointer,
  1193  	// non-interface field appearing in ForceSendFields will be sent to the
  1194  	// server regardless of whether the field is empty or not. This may be
  1195  	// used to include empty fields in Patch requests.
  1196  	ForceSendFields []string `json:"-"`
  1197  
  1198  	// NullFields is a list of field names (e.g. "AcceleratorCount") to
  1199  	// include in API requests with the JSON null value. By default, fields
  1200  	// with empty values are omitted from API requests. However, any field
  1201  	// with an empty value appearing in NullFields will be sent to the
  1202  	// server as null. It is an error if a field in this list has a
  1203  	// non-empty value. This may be used to include null fields in Patch
  1204  	// requests.
  1205  	NullFields []string `json:"-"`
  1206  }
  1207  
  1208  func (s *PipelineResources) MarshalJSON() ([]byte, error) {
  1209  	type NoMethod PipelineResources
  1210  	raw := NoMethod(*s)
  1211  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1212  }
  1213  
  1214  func (s *PipelineResources) UnmarshalJSON(data []byte) error {
  1215  	type NoMethod PipelineResources
  1216  	var s1 struct {
  1217  		MinimumRamGb gensupport.JSONFloat64 `json:"minimumRamGb"`
  1218  		*NoMethod
  1219  	}
  1220  	s1.NoMethod = (*NoMethod)(s)
  1221  	if err := json.Unmarshal(data, &s1); err != nil {
  1222  		return err
  1223  	}
  1224  	s.MinimumRamGb = float64(s1.MinimumRamGb)
  1225  	return nil
  1226  }
  1227  
  1228  // PullStartedEvent: An event generated when the worker starts pulling
  1229  // an image.
  1230  type PullStartedEvent struct {
  1231  	// ImageUri: The URI of the image that was pulled.
  1232  	ImageUri string `json:"imageUri,omitempty"`
  1233  
  1234  	// ForceSendFields is a list of field names (e.g. "ImageUri") to
  1235  	// unconditionally include in API requests. By default, fields with
  1236  	// empty values are omitted from API requests. However, any non-pointer,
  1237  	// non-interface field appearing in ForceSendFields will be sent to the
  1238  	// server regardless of whether the field is empty or not. This may be
  1239  	// used to include empty fields in Patch requests.
  1240  	ForceSendFields []string `json:"-"`
  1241  
  1242  	// NullFields is a list of field names (e.g. "ImageUri") to include in
  1243  	// API requests with the JSON null value. By default, fields with empty
  1244  	// values are omitted from API requests. However, any field with an
  1245  	// empty value appearing in NullFields will be sent to the server as
  1246  	// null. It is an error if a field in this list has a non-empty value.
  1247  	// This may be used to include null fields in Patch requests.
  1248  	NullFields []string `json:"-"`
  1249  }
  1250  
  1251  func (s *PullStartedEvent) MarshalJSON() ([]byte, error) {
  1252  	type NoMethod PullStartedEvent
  1253  	raw := NoMethod(*s)
  1254  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1255  }
  1256  
  1257  // PullStoppedEvent: An event generated when the worker stops pulling an
  1258  // image.
  1259  type PullStoppedEvent struct {
  1260  	// ImageUri: The URI of the image that was pulled.
  1261  	ImageUri string `json:"imageUri,omitempty"`
  1262  
  1263  	// ForceSendFields is a list of field names (e.g. "ImageUri") to
  1264  	// unconditionally include in API requests. By default, fields with
  1265  	// empty values are omitted from API requests. However, any non-pointer,
  1266  	// non-interface field appearing in ForceSendFields will be sent to the
  1267  	// server regardless of whether the field is empty or not. This may be
  1268  	// used to include empty fields in Patch requests.
  1269  	ForceSendFields []string `json:"-"`
  1270  
  1271  	// NullFields is a list of field names (e.g. "ImageUri") to include in
  1272  	// API requests with the JSON null value. By default, fields with empty
  1273  	// values are omitted from API requests. However, any field with an
  1274  	// empty value appearing in NullFields will be sent to the server as
  1275  	// null. It is an error if a field in this list has a non-empty value.
  1276  	// This may be used to include null fields in Patch requests.
  1277  	NullFields []string `json:"-"`
  1278  }
  1279  
  1280  func (s *PullStoppedEvent) MarshalJSON() ([]byte, error) {
  1281  	type NoMethod PullStoppedEvent
  1282  	raw := NoMethod(*s)
  1283  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1284  }
  1285  
  1286  type RepeatedString struct {
  1287  	Values []string `json:"values,omitempty"`
  1288  
  1289  	// ForceSendFields is a list of field names (e.g. "Values") to
  1290  	// unconditionally include in API requests. By default, fields with
  1291  	// empty values are omitted from API requests. However, any non-pointer,
  1292  	// non-interface field appearing in ForceSendFields will be sent to the
  1293  	// server regardless of whether the field is empty or not. This may be
  1294  	// used to include empty fields in Patch requests.
  1295  	ForceSendFields []string `json:"-"`
  1296  
  1297  	// NullFields is a list of field names (e.g. "Values") to include in API
  1298  	// requests with the JSON null value. By default, fields with empty
  1299  	// values are omitted from API requests. However, any field with an
  1300  	// empty value appearing in NullFields will be sent to the server as
  1301  	// null. It is an error if a field in this list has a non-empty value.
  1302  	// This may be used to include null fields in Patch requests.
  1303  	NullFields []string `json:"-"`
  1304  }
  1305  
  1306  func (s *RepeatedString) MarshalJSON() ([]byte, error) {
  1307  	type NoMethod RepeatedString
  1308  	raw := NoMethod(*s)
  1309  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1310  }
  1311  
  1312  // RunPipelineArgs: The pipeline run arguments.
  1313  type RunPipelineArgs struct {
  1314  	// ClientId: This field is deprecated. Use `labels` instead.
  1315  	// Client-specified pipeline operation identifier.
  1316  	ClientId string `json:"clientId,omitempty"`
  1317  
  1318  	// Inputs: Pipeline input arguments; keys are defined in the pipeline
  1319  	// documentation. All input parameters that do not have default values
  1320  	// must be specified. If parameters with defaults are specified here,
  1321  	// the defaults will be overridden.
  1322  	Inputs map[string]string `json:"inputs,omitempty"`
  1323  
  1324  	// KeepVmAliveOnFailureDuration: How long to keep the VM up after a
  1325  	// failure (for example docker command failed, copying input or output
  1326  	// files failed, etc). While the VM is up, one can ssh into the VM to
  1327  	// debug. Default is 0; maximum allowed value is 1 day.
  1328  	KeepVmAliveOnFailureDuration string `json:"keepVmAliveOnFailureDuration,omitempty"`
  1329  
  1330  	// Labels: Labels to apply to this pipeline run. Labels will also be
  1331  	// applied to compute resources (VM, disks) created by this pipeline
  1332  	// run. When listing operations, operations can filtered by labels.
  1333  	// Label keys may not be empty; label values may be empty. Non-empty
  1334  	// labels must be 1-63 characters long, and comply with [RFC1035]
  1335  	// (https://www.ietf.org/rfc/rfc1035.txt). Specifically, the name must
  1336  	// be 1-63 characters long and match the regular expression
  1337  	// `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be
  1338  	// a lowercase letter, and all following characters must be a dash,
  1339  	// lowercase letter, or digit, except the last character, which cannot
  1340  	// be a dash.
  1341  	Labels map[string]string `json:"labels,omitempty"`
  1342  
  1343  	// Logging: Required. Logging options. Used by the service to
  1344  	// communicate results to the user.
  1345  	Logging *LoggingOptions `json:"logging,omitempty"`
  1346  
  1347  	// Outputs: Pipeline output arguments; keys are defined in the pipeline
  1348  	// documentation. All output parameters of without default values must
  1349  	// be specified. If parameters with defaults are specified here, the
  1350  	// defaults will be overridden.
  1351  	Outputs map[string]string `json:"outputs,omitempty"`
  1352  
  1353  	// ProjectId: Required. The project in which to run the pipeline. The
  1354  	// caller must have WRITER access to all Google Cloud services and
  1355  	// resources (e.g. Google Compute Engine) will be used.
  1356  	ProjectId string `json:"projectId,omitempty"`
  1357  
  1358  	// Resources: Specifies resource requirements/overrides for the pipeline
  1359  	// run.
  1360  	Resources *PipelineResources `json:"resources,omitempty"`
  1361  
  1362  	// ServiceAccount: The Google Cloud Service Account that will be used to
  1363  	// access data and services. By default, the compute service account
  1364  	// associated with `projectId` is used.
  1365  	ServiceAccount *ServiceAccount `json:"serviceAccount,omitempty"`
  1366  
  1367  	// ForceSendFields is a list of field names (e.g. "ClientId") to
  1368  	// unconditionally include in API requests. By default, fields with
  1369  	// empty values are omitted from API requests. However, any non-pointer,
  1370  	// non-interface field appearing in ForceSendFields will be sent to the
  1371  	// server regardless of whether the field is empty or not. This may be
  1372  	// used to include empty fields in Patch requests.
  1373  	ForceSendFields []string `json:"-"`
  1374  
  1375  	// NullFields is a list of field names (e.g. "ClientId") to include in
  1376  	// API requests with the JSON null value. By default, fields with empty
  1377  	// values are omitted from API requests. However, any field with an
  1378  	// empty value appearing in NullFields will be sent to the server as
  1379  	// null. It is an error if a field in this list has a non-empty value.
  1380  	// This may be used to include null fields in Patch requests.
  1381  	NullFields []string `json:"-"`
  1382  }
  1383  
  1384  func (s *RunPipelineArgs) MarshalJSON() ([]byte, error) {
  1385  	type NoMethod RunPipelineArgs
  1386  	raw := NoMethod(*s)
  1387  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1388  }
  1389  
  1390  // RunPipelineRequest: The request to run a pipeline. If `pipelineId` is
  1391  // specified, it refers to a saved pipeline created with CreatePipeline
  1392  // and set as the `pipelineId` of the returned Pipeline object. If
  1393  // `ephemeralPipeline` is specified, that pipeline is run once with the
  1394  // given args and not saved. It is an error to specify both `pipelineId`
  1395  // and `ephemeralPipeline`. `pipelineArgs` must be specified.
  1396  type RunPipelineRequest struct {
  1397  	// EphemeralPipeline: A new pipeline object to run once and then delete.
  1398  	EphemeralPipeline *Pipeline `json:"ephemeralPipeline,omitempty"`
  1399  
  1400  	// PipelineArgs: The arguments to use when running this pipeline.
  1401  	PipelineArgs *RunPipelineArgs `json:"pipelineArgs,omitempty"`
  1402  
  1403  	// PipelineId: The already created pipeline to run.
  1404  	PipelineId string `json:"pipelineId,omitempty"`
  1405  
  1406  	// ForceSendFields is a list of field names (e.g. "EphemeralPipeline")
  1407  	// to unconditionally include in API requests. By default, fields with
  1408  	// empty values are omitted from API requests. However, any non-pointer,
  1409  	// non-interface field appearing in ForceSendFields will be sent to the
  1410  	// server regardless of whether the field is empty or not. This may be
  1411  	// used to include empty fields in Patch requests.
  1412  	ForceSendFields []string `json:"-"`
  1413  
  1414  	// NullFields is a list of field names (e.g. "EphemeralPipeline") to
  1415  	// include in API requests with the JSON null value. By default, fields
  1416  	// with empty values are omitted from API requests. However, any field
  1417  	// with an empty value appearing in NullFields will be sent to the
  1418  	// server as null. It is an error if a field in this list has a
  1419  	// non-empty value. This may be used to include null fields in Patch
  1420  	// requests.
  1421  	NullFields []string `json:"-"`
  1422  }
  1423  
  1424  func (s *RunPipelineRequest) MarshalJSON() ([]byte, error) {
  1425  	type NoMethod RunPipelineRequest
  1426  	raw := NoMethod(*s)
  1427  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1428  }
  1429  
  1430  // RunPipelineResponse: The response to the RunPipeline method, returned
  1431  // in the operation's result field on success.
  1432  type RunPipelineResponse struct {
  1433  }
  1434  
  1435  // RuntimeMetadata: Runtime metadata that will be populated in the
  1436  // runtimeMetadata field of the Operation associated with a RunPipeline
  1437  // execution.
  1438  type RuntimeMetadata struct {
  1439  	// ComputeEngine: Execution information specific to Google Compute
  1440  	// Engine.
  1441  	ComputeEngine *ComputeEngine `json:"computeEngine,omitempty"`
  1442  
  1443  	// ForceSendFields is a list of field names (e.g. "ComputeEngine") to
  1444  	// unconditionally include in API requests. By default, fields with
  1445  	// empty values are omitted from API requests. However, any non-pointer,
  1446  	// non-interface field appearing in ForceSendFields will be sent to the
  1447  	// server regardless of whether the field is empty or not. This may be
  1448  	// used to include empty fields in Patch requests.
  1449  	ForceSendFields []string `json:"-"`
  1450  
  1451  	// NullFields is a list of field names (e.g. "ComputeEngine") to include
  1452  	// in API requests with the JSON null value. By default, fields with
  1453  	// empty values are omitted from API requests. However, any field with
  1454  	// an empty value appearing in NullFields will be sent to the server as
  1455  	// null. It is an error if a field in this list has a non-empty value.
  1456  	// This may be used to include null fields in Patch requests.
  1457  	NullFields []string `json:"-"`
  1458  }
  1459  
  1460  func (s *RuntimeMetadata) MarshalJSON() ([]byte, error) {
  1461  	type NoMethod RuntimeMetadata
  1462  	raw := NoMethod(*s)
  1463  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1464  }
  1465  
  1466  // ServiceAccount: A Google Cloud Service Account.
  1467  type ServiceAccount struct {
  1468  	// Email: Email address of the service account. Defaults to `default`,
  1469  	// which uses the compute service account associated with the project.
  1470  	Email string `json:"email,omitempty"`
  1471  
  1472  	// Scopes: List of scopes to be enabled for this service account on the
  1473  	// VM. The following scopes are automatically included: *
  1474  	// https://www.googleapis.com/auth/compute *
  1475  	// https://www.googleapis.com/auth/devstorage.full_control *
  1476  	// https://www.googleapis.com/auth/genomics *
  1477  	// https://www.googleapis.com/auth/logging.write *
  1478  	// https://www.googleapis.com/auth/monitoring.write
  1479  	Scopes []string `json:"scopes,omitempty"`
  1480  
  1481  	// ForceSendFields is a list of field names (e.g. "Email") to
  1482  	// unconditionally include in API requests. By default, fields with
  1483  	// empty values are omitted from API requests. However, any non-pointer,
  1484  	// non-interface field appearing in ForceSendFields will be sent to the
  1485  	// server regardless of whether the field is empty or not. This may be
  1486  	// used to include empty fields in Patch requests.
  1487  	ForceSendFields []string `json:"-"`
  1488  
  1489  	// NullFields is a list of field names (e.g. "Email") to include in API
  1490  	// requests with the JSON null value. By default, fields with empty
  1491  	// values are omitted from API requests. However, any field with an
  1492  	// empty value appearing in NullFields will be sent to the server as
  1493  	// null. It is an error if a field in this list has a non-empty value.
  1494  	// This may be used to include null fields in Patch requests.
  1495  	NullFields []string `json:"-"`
  1496  }
  1497  
  1498  func (s *ServiceAccount) MarshalJSON() ([]byte, error) {
  1499  	type NoMethod ServiceAccount
  1500  	raw := NoMethod(*s)
  1501  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1502  }
  1503  
  1504  // SetOperationStatusRequest: Request to set operation status. Should
  1505  // only be used by VMs created by the Pipelines Service and not by end
  1506  // users.
  1507  type SetOperationStatusRequest struct {
  1508  	// Possible values:
  1509  	//   "OK" - Not an error; returned on success HTTP Mapping: 200 OK
  1510  	//   "CANCELLED" - The operation was cancelled, typically by the caller.
  1511  	// HTTP Mapping: 499 Client Closed Request
  1512  	//   "UNKNOWN" - Unknown error. For example, this error may be returned
  1513  	// when a `Status` value received from another address space belongs to
  1514  	// an error space that is not known in this address space. Also errors
  1515  	// raised by APIs that do not return enough error information may be
  1516  	// converted to this error. HTTP Mapping: 500 Internal Server Error
  1517  	//   "INVALID_ARGUMENT" - The client specified an invalid argument. Note
  1518  	// that this differs from `FAILED_PRECONDITION`. `INVALID_ARGUMENT`
  1519  	// indicates arguments that are problematic regardless of the state of
  1520  	// the system (e.g., a malformed file name). HTTP Mapping: 400 Bad
  1521  	// Request
  1522  	//   "DEADLINE_EXCEEDED" - The deadline expired before the operation
  1523  	// could complete. For operations that change the state of the system,
  1524  	// this error may be returned even if the operation has completed
  1525  	// successfully. For example, a successful response from a server could
  1526  	// have been delayed long enough for the deadline to expire. HTTP
  1527  	// Mapping: 504 Gateway Timeout
  1528  	//   "NOT_FOUND" - Some requested entity (e.g., file or directory) was
  1529  	// not found. Note to server developers: if a request is denied for an
  1530  	// entire class of users, such as gradual feature rollout or
  1531  	// undocumented allowlist, `NOT_FOUND` may be used. If a request is
  1532  	// denied for some users within a class of users, such as user-based
  1533  	// access control, `PERMISSION_DENIED` must be used. HTTP Mapping: 404
  1534  	// Not Found
  1535  	//   "ALREADY_EXISTS" - The entity that a client attempted to create
  1536  	// (e.g., file or directory) already exists. HTTP Mapping: 409 Conflict
  1537  	//   "PERMISSION_DENIED" - The caller does not have permission to
  1538  	// execute the specified operation. `PERMISSION_DENIED` must not be used
  1539  	// for rejections caused by exhausting some resource (use
  1540  	// `RESOURCE_EXHAUSTED` instead for those errors). `PERMISSION_DENIED`
  1541  	// must not be used if the caller can not be identified (use
  1542  	// `UNAUTHENTICATED` instead for those errors). This error code does not
  1543  	// imply the request is valid or the requested entity exists or
  1544  	// satisfies other pre-conditions. HTTP Mapping: 403 Forbidden
  1545  	//   "UNAUTHENTICATED" - The request does not have valid authentication
  1546  	// credentials for the operation. HTTP Mapping: 401 Unauthorized
  1547  	//   "RESOURCE_EXHAUSTED" - Some resource has been exhausted, perhaps a
  1548  	// per-user quota, or perhaps the entire file system is out of space.
  1549  	// HTTP Mapping: 429 Too Many Requests
  1550  	//   "FAILED_PRECONDITION" - The operation was rejected because the
  1551  	// system is not in a state required for the operation's execution. For
  1552  	// example, the directory to be deleted is non-empty, an rmdir operation
  1553  	// is applied to a non-directory, etc. Service implementors can use the
  1554  	// following guidelines to decide between `FAILED_PRECONDITION`,
  1555  	// `ABORTED`, and `UNAVAILABLE`: (a) Use `UNAVAILABLE` if the client can
  1556  	// retry just the failing call. (b) Use `ABORTED` if the client should
  1557  	// retry at a higher level. For example, when a client-specified
  1558  	// test-and-set fails, indicating the client should restart a
  1559  	// read-modify-write sequence. (c) Use `FAILED_PRECONDITION` if the
  1560  	// client should not retry until the system state has been explicitly
  1561  	// fixed. For example, if an "rmdir" fails because the directory is
  1562  	// non-empty, `FAILED_PRECONDITION` should be returned since the client
  1563  	// should not retry unless the files are deleted from the directory.
  1564  	// HTTP Mapping: 400 Bad Request
  1565  	//   "ABORTED" - The operation was aborted, typically due to a
  1566  	// concurrency issue such as a sequencer check failure or transaction
  1567  	// abort. See the guidelines above for deciding between
  1568  	// `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`. HTTP Mapping:
  1569  	// 409 Conflict
  1570  	//   "OUT_OF_RANGE" - The operation was attempted past the valid range.
  1571  	// E.g., seeking or reading past end-of-file. Unlike `INVALID_ARGUMENT`,
  1572  	// this error indicates a problem that may be fixed if the system state
  1573  	// changes. For example, a 32-bit file system will generate
  1574  	// `INVALID_ARGUMENT` if asked to read at an offset that is not in the
  1575  	// range [0,2^32-1], but it will generate `OUT_OF_RANGE` if asked to
  1576  	// read from an offset past the current file size. There is a fair bit
  1577  	// of overlap between `FAILED_PRECONDITION` and `OUT_OF_RANGE`. We
  1578  	// recommend using `OUT_OF_RANGE` (the more specific error) when it
  1579  	// applies so that callers who are iterating through a space can easily
  1580  	// look for an `OUT_OF_RANGE` error to detect when they are done. HTTP
  1581  	// Mapping: 400 Bad Request
  1582  	//   "UNIMPLEMENTED" - The operation is not implemented or is not
  1583  	// supported/enabled in this service. HTTP Mapping: 501 Not Implemented
  1584  	//   "INTERNAL" - Internal errors. This means that some invariants
  1585  	// expected by the underlying system have been broken. This error code
  1586  	// is reserved for serious errors. HTTP Mapping: 500 Internal Server
  1587  	// Error
  1588  	//   "UNAVAILABLE" - The service is currently unavailable. This is most
  1589  	// likely a transient condition, which can be corrected by retrying with
  1590  	// a backoff. Note that it is not always safe to retry non-idempotent
  1591  	// operations. See the guidelines above for deciding between
  1592  	// `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`. HTTP Mapping:
  1593  	// 503 Service Unavailable
  1594  	//   "DATA_LOSS" - Unrecoverable data loss or corruption. HTTP Mapping:
  1595  	// 500 Internal Server Error
  1596  	ErrorCode string `json:"errorCode,omitempty"`
  1597  
  1598  	ErrorMessage string `json:"errorMessage,omitempty"`
  1599  
  1600  	OperationId string `json:"operationId,omitempty"`
  1601  
  1602  	TimestampEvents []*TimestampEvent `json:"timestampEvents,omitempty"`
  1603  
  1604  	ValidationToken uint64 `json:"validationToken,omitempty,string"`
  1605  
  1606  	// ForceSendFields is a list of field names (e.g. "ErrorCode") to
  1607  	// unconditionally include in API requests. By default, fields with
  1608  	// empty values are omitted from API requests. However, any non-pointer,
  1609  	// non-interface field appearing in ForceSendFields will be sent to the
  1610  	// server regardless of whether the field is empty or not. This may be
  1611  	// used to include empty fields in Patch requests.
  1612  	ForceSendFields []string `json:"-"`
  1613  
  1614  	// NullFields is a list of field names (e.g. "ErrorCode") to include in
  1615  	// API requests with the JSON null value. By default, fields with empty
  1616  	// values are omitted from API requests. However, any field with an
  1617  	// empty value appearing in NullFields will be sent to the server as
  1618  	// null. It is an error if a field in this list has a non-empty value.
  1619  	// This may be used to include null fields in Patch requests.
  1620  	NullFields []string `json:"-"`
  1621  }
  1622  
  1623  func (s *SetOperationStatusRequest) MarshalJSON() ([]byte, error) {
  1624  	type NoMethod SetOperationStatusRequest
  1625  	raw := NoMethod(*s)
  1626  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1627  }
  1628  
  1629  // Status: The `Status` type defines a logical error model that is
  1630  // suitable for different programming environments, including REST APIs
  1631  // and RPC APIs. It is used by gRPC (https://github.com/grpc). Each
  1632  // `Status` message contains three pieces of data: error code, error
  1633  // message, and error details. You can find out more about this error
  1634  // model and how to work with it in the API Design Guide
  1635  // (https://cloud.google.com/apis/design/errors).
  1636  type Status struct {
  1637  	// Code: The status code, which should be an enum value of
  1638  	// google.rpc.Code.
  1639  	Code int64 `json:"code,omitempty"`
  1640  
  1641  	// Details: A list of messages that carry the error details. There is a
  1642  	// common set of message types for APIs to use.
  1643  	Details []googleapi.RawMessage `json:"details,omitempty"`
  1644  
  1645  	// Message: A developer-facing error message, which should be in
  1646  	// English. Any user-facing error message should be localized and sent
  1647  	// in the google.rpc.Status.details field, or localized by the client.
  1648  	Message string `json:"message,omitempty"`
  1649  
  1650  	// ForceSendFields is a list of field names (e.g. "Code") to
  1651  	// unconditionally include in API requests. By default, fields with
  1652  	// empty values are omitted from API requests. However, any non-pointer,
  1653  	// non-interface field appearing in ForceSendFields will be sent to the
  1654  	// server regardless of whether the field is empty or not. This may be
  1655  	// used to include empty fields in Patch requests.
  1656  	ForceSendFields []string `json:"-"`
  1657  
  1658  	// NullFields is a list of field names (e.g. "Code") to include in API
  1659  	// requests with the JSON null value. By default, fields with empty
  1660  	// values are omitted from API requests. However, any field with an
  1661  	// empty value appearing in NullFields will be sent to the server as
  1662  	// null. It is an error if a field in this list has a non-empty value.
  1663  	// This may be used to include null fields in Patch requests.
  1664  	NullFields []string `json:"-"`
  1665  }
  1666  
  1667  func (s *Status) MarshalJSON() ([]byte, error) {
  1668  	type NoMethod Status
  1669  	raw := NoMethod(*s)
  1670  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1671  }
  1672  
  1673  // TimestampEvent: Stores the list of events and times they occured for
  1674  // major events in job execution.
  1675  type TimestampEvent struct {
  1676  	// Description: String indicating the type of event
  1677  	Description string `json:"description,omitempty"`
  1678  
  1679  	// Timestamp: The time this event occured.
  1680  	Timestamp string `json:"timestamp,omitempty"`
  1681  
  1682  	// ForceSendFields is a list of field names (e.g. "Description") to
  1683  	// unconditionally include in API requests. By default, fields with
  1684  	// empty values are omitted from API requests. However, any non-pointer,
  1685  	// non-interface field appearing in ForceSendFields will be sent to the
  1686  	// server regardless of whether the field is empty or not. This may be
  1687  	// used to include empty fields in Patch requests.
  1688  	ForceSendFields []string `json:"-"`
  1689  
  1690  	// NullFields is a list of field names (e.g. "Description") to include
  1691  	// in API requests with the JSON null value. By default, fields with
  1692  	// empty values are omitted from API requests. However, any field with
  1693  	// an empty value appearing in NullFields will be sent to the server as
  1694  	// null. It is an error if a field in this list has a non-empty value.
  1695  	// This may be used to include null fields in Patch requests.
  1696  	NullFields []string `json:"-"`
  1697  }
  1698  
  1699  func (s *TimestampEvent) MarshalJSON() ([]byte, error) {
  1700  	type NoMethod TimestampEvent
  1701  	raw := NoMethod(*s)
  1702  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1703  }
  1704  
  1705  // UnexpectedExitStatusEvent: An event generated when the execution of a
  1706  // container results in a non-zero exit status that was not otherwise
  1707  // ignored. Execution will continue, but only actions that are flagged
  1708  // as `ALWAYS_RUN` will be executed. Other actions will be skipped.
  1709  type UnexpectedExitStatusEvent struct {
  1710  	// ActionId: The numeric ID of the action that started the container.
  1711  	ActionId int64 `json:"actionId,omitempty"`
  1712  
  1713  	// ExitStatus: The exit status of the container.
  1714  	ExitStatus int64 `json:"exitStatus,omitempty"`
  1715  
  1716  	// ForceSendFields is a list of field names (e.g. "ActionId") to
  1717  	// unconditionally include in API requests. By default, fields with
  1718  	// empty values are omitted from API requests. However, any non-pointer,
  1719  	// non-interface field appearing in ForceSendFields will be sent to the
  1720  	// server regardless of whether the field is empty or not. This may be
  1721  	// used to include empty fields in Patch requests.
  1722  	ForceSendFields []string `json:"-"`
  1723  
  1724  	// NullFields is a list of field names (e.g. "ActionId") to include in
  1725  	// API requests with the JSON null value. By default, fields with empty
  1726  	// values are omitted from API requests. However, any field with an
  1727  	// empty value appearing in NullFields will be sent to the server as
  1728  	// null. It is an error if a field in this list has a non-empty value.
  1729  	// This may be used to include null fields in Patch requests.
  1730  	NullFields []string `json:"-"`
  1731  }
  1732  
  1733  func (s *UnexpectedExitStatusEvent) MarshalJSON() ([]byte, error) {
  1734  	type NoMethod UnexpectedExitStatusEvent
  1735  	raw := NoMethod(*s)
  1736  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1737  }
  1738  
  1739  // WorkerAssignedEvent: An event generated after a worker VM has been
  1740  // assigned to run the pipeline.
  1741  type WorkerAssignedEvent struct {
  1742  	// Instance: The worker's instance name.
  1743  	Instance string `json:"instance,omitempty"`
  1744  
  1745  	// MachineType: The machine type that was assigned for the worker.
  1746  	MachineType string `json:"machineType,omitempty"`
  1747  
  1748  	// Zone: The zone the worker is running in.
  1749  	Zone string `json:"zone,omitempty"`
  1750  
  1751  	// ForceSendFields is a list of field names (e.g. "Instance") to
  1752  	// unconditionally include in API requests. By default, fields with
  1753  	// empty values are omitted from API requests. However, any non-pointer,
  1754  	// non-interface field appearing in ForceSendFields will be sent to the
  1755  	// server regardless of whether the field is empty or not. This may be
  1756  	// used to include empty fields in Patch requests.
  1757  	ForceSendFields []string `json:"-"`
  1758  
  1759  	// NullFields is a list of field names (e.g. "Instance") to include in
  1760  	// API requests with the JSON null value. By default, fields with empty
  1761  	// values are omitted from API requests. However, any field with an
  1762  	// empty value appearing in NullFields will be sent to the server as
  1763  	// null. It is an error if a field in this list has a non-empty value.
  1764  	// This may be used to include null fields in Patch requests.
  1765  	NullFields []string `json:"-"`
  1766  }
  1767  
  1768  func (s *WorkerAssignedEvent) MarshalJSON() ([]byte, error) {
  1769  	type NoMethod WorkerAssignedEvent
  1770  	raw := NoMethod(*s)
  1771  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1772  }
  1773  
  1774  // WorkerReleasedEvent: An event generated when the worker VM that was
  1775  // assigned to the pipeline has been released (deleted).
  1776  type WorkerReleasedEvent struct {
  1777  	// Instance: The worker's instance name.
  1778  	Instance string `json:"instance,omitempty"`
  1779  
  1780  	// Zone: The zone the worker was running in.
  1781  	Zone string `json:"zone,omitempty"`
  1782  
  1783  	// ForceSendFields is a list of field names (e.g. "Instance") to
  1784  	// unconditionally include in API requests. By default, fields with
  1785  	// empty values are omitted from API requests. However, any non-pointer,
  1786  	// non-interface field appearing in ForceSendFields will be sent to the
  1787  	// server regardless of whether the field is empty or not. This may be
  1788  	// used to include empty fields in Patch requests.
  1789  	ForceSendFields []string `json:"-"`
  1790  
  1791  	// NullFields is a list of field names (e.g. "Instance") to include in
  1792  	// API requests with the JSON null value. By default, fields with empty
  1793  	// values are omitted from API requests. However, any field with an
  1794  	// empty value appearing in NullFields will be sent to the server as
  1795  	// null. It is an error if a field in this list has a non-empty value.
  1796  	// This may be used to include null fields in Patch requests.
  1797  	NullFields []string `json:"-"`
  1798  }
  1799  
  1800  func (s *WorkerReleasedEvent) MarshalJSON() ([]byte, error) {
  1801  	type NoMethod WorkerReleasedEvent
  1802  	raw := NoMethod(*s)
  1803  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1804  }
  1805  
  1806  // method id "genomics.operations.cancel":
  1807  
  1808  type OperationsCancelCall struct {
  1809  	s                      *Service
  1810  	name                   string
  1811  	canceloperationrequest *CancelOperationRequest
  1812  	urlParams_             gensupport.URLParams
  1813  	ctx_                   context.Context
  1814  	header_                http.Header
  1815  }
  1816  
  1817  // Cancel: Starts asynchronous cancellation on a long-running operation.
  1818  // The server makes a best effort to cancel the operation, but success
  1819  // is not guaranteed. Clients may use Operations.GetOperation or
  1820  // Operations.ListOperations to check whether the cancellation succeeded
  1821  // or the operation completed despite cancellation. Authorization
  1822  // requires the following Google IAM (https://cloud.google.com/iam)
  1823  // permission: * `genomics.operations.cancel`
  1824  //
  1825  // - name: The name of the operation resource to be cancelled.
  1826  func (r *OperationsService) Cancel(name string, canceloperationrequest *CancelOperationRequest) *OperationsCancelCall {
  1827  	c := &OperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1828  	c.name = name
  1829  	c.canceloperationrequest = canceloperationrequest
  1830  	return c
  1831  }
  1832  
  1833  // Fields allows partial responses to be retrieved. See
  1834  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1835  // for more information.
  1836  func (c *OperationsCancelCall) Fields(s ...googleapi.Field) *OperationsCancelCall {
  1837  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1838  	return c
  1839  }
  1840  
  1841  // Context sets the context to be used in this call's Do method. Any
  1842  // pending HTTP request will be aborted if the provided context is
  1843  // canceled.
  1844  func (c *OperationsCancelCall) Context(ctx context.Context) *OperationsCancelCall {
  1845  	c.ctx_ = ctx
  1846  	return c
  1847  }
  1848  
  1849  // Header returns an http.Header that can be modified by the caller to
  1850  // add HTTP headers to the request.
  1851  func (c *OperationsCancelCall) Header() http.Header {
  1852  	if c.header_ == nil {
  1853  		c.header_ = make(http.Header)
  1854  	}
  1855  	return c.header_
  1856  }
  1857  
  1858  func (c *OperationsCancelCall) doRequest(alt string) (*http.Response, error) {
  1859  	reqHeaders := make(http.Header)
  1860  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  1861  	for k, v := range c.header_ {
  1862  		reqHeaders[k] = v
  1863  	}
  1864  	reqHeaders.Set("User-Agent", c.s.userAgent())
  1865  	var body io.Reader = nil
  1866  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.canceloperationrequest)
  1867  	if err != nil {
  1868  		return nil, err
  1869  	}
  1870  	reqHeaders.Set("Content-Type", "application/json")
  1871  	c.urlParams_.Set("alt", alt)
  1872  	c.urlParams_.Set("prettyPrint", "false")
  1873  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}:cancel")
  1874  	urls += "?" + c.urlParams_.Encode()
  1875  	req, err := http.NewRequest("POST", urls, body)
  1876  	if err != nil {
  1877  		return nil, err
  1878  	}
  1879  	req.Header = reqHeaders
  1880  	googleapi.Expand(req.URL, map[string]string{
  1881  		"name": c.name,
  1882  	})
  1883  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1884  }
  1885  
  1886  // Do executes the "genomics.operations.cancel" call.
  1887  // Exactly one of *Empty or error will be non-nil. Any non-2xx status
  1888  // code is an error. Response headers are in either
  1889  // *Empty.ServerResponse.Header or (if a response was returned at all)
  1890  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  1891  // check whether the returned error was because http.StatusNotModified
  1892  // was returned.
  1893  func (c *OperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  1894  	gensupport.SetOptions(c.urlParams_, opts...)
  1895  	res, err := c.doRequest("json")
  1896  	if res != nil && res.StatusCode == http.StatusNotModified {
  1897  		if res.Body != nil {
  1898  			res.Body.Close()
  1899  		}
  1900  		return nil, &googleapi.Error{
  1901  			Code:   res.StatusCode,
  1902  			Header: res.Header,
  1903  		}
  1904  	}
  1905  	if err != nil {
  1906  		return nil, err
  1907  	}
  1908  	defer googleapi.CloseBody(res)
  1909  	if err := googleapi.CheckResponse(res); err != nil {
  1910  		return nil, err
  1911  	}
  1912  	ret := &Empty{
  1913  		ServerResponse: googleapi.ServerResponse{
  1914  			Header:         res.Header,
  1915  			HTTPStatusCode: res.StatusCode,
  1916  		},
  1917  	}
  1918  	target := &ret
  1919  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1920  		return nil, err
  1921  	}
  1922  	return ret, nil
  1923  	// {
  1924  	//   "description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients may use Operations.GetOperation or Operations.ListOperations to check whether the cancellation succeeded or the operation completed despite cancellation. Authorization requires the following [Google IAM](https://cloud.google.com/iam) permission: * `genomics.operations.cancel`",
  1925  	//   "flatPath": "v1alpha2/operations/{operationsId}:cancel",
  1926  	//   "httpMethod": "POST",
  1927  	//   "id": "genomics.operations.cancel",
  1928  	//   "parameterOrder": [
  1929  	//     "name"
  1930  	//   ],
  1931  	//   "parameters": {
  1932  	//     "name": {
  1933  	//       "description": "The name of the operation resource to be cancelled.",
  1934  	//       "location": "path",
  1935  	//       "pattern": "^operations/.*$",
  1936  	//       "required": true,
  1937  	//       "type": "string"
  1938  	//     }
  1939  	//   },
  1940  	//   "path": "v1alpha2/{+name}:cancel",
  1941  	//   "request": {
  1942  	//     "$ref": "CancelOperationRequest"
  1943  	//   },
  1944  	//   "response": {
  1945  	//     "$ref": "Empty"
  1946  	//   },
  1947  	//   "scopes": [
  1948  	//     "https://www.googleapis.com/auth/cloud-platform",
  1949  	//     "https://www.googleapis.com/auth/genomics"
  1950  	//   ]
  1951  	// }
  1952  
  1953  }
  1954  
  1955  // method id "genomics.operations.get":
  1956  
  1957  type OperationsGetCall struct {
  1958  	s            *Service
  1959  	name         string
  1960  	urlParams_   gensupport.URLParams
  1961  	ifNoneMatch_ string
  1962  	ctx_         context.Context
  1963  	header_      http.Header
  1964  }
  1965  
  1966  // Get: Gets the latest state of a long-running operation. Clients can
  1967  // use this method to poll the operation result at intervals as
  1968  // recommended by the API service. Authorization requires the following
  1969  // Google IAM (https://cloud.google.com/iam) permission: *
  1970  // `genomics.operations.get`
  1971  //
  1972  // - name: The name of the operation resource.
  1973  func (r *OperationsService) Get(name string) *OperationsGetCall {
  1974  	c := &OperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1975  	c.name = name
  1976  	return c
  1977  }
  1978  
  1979  // Fields allows partial responses to be retrieved. See
  1980  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1981  // for more information.
  1982  func (c *OperationsGetCall) Fields(s ...googleapi.Field) *OperationsGetCall {
  1983  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1984  	return c
  1985  }
  1986  
  1987  // IfNoneMatch sets the optional parameter which makes the operation
  1988  // fail if the object's ETag matches the given value. This is useful for
  1989  // getting updates only after the object has changed since the last
  1990  // request. Use googleapi.IsNotModified to check whether the response
  1991  // error from Do is the result of In-None-Match.
  1992  func (c *OperationsGetCall) IfNoneMatch(entityTag string) *OperationsGetCall {
  1993  	c.ifNoneMatch_ = entityTag
  1994  	return c
  1995  }
  1996  
  1997  // Context sets the context to be used in this call's Do method. Any
  1998  // pending HTTP request will be aborted if the provided context is
  1999  // canceled.
  2000  func (c *OperationsGetCall) Context(ctx context.Context) *OperationsGetCall {
  2001  	c.ctx_ = ctx
  2002  	return c
  2003  }
  2004  
  2005  // Header returns an http.Header that can be modified by the caller to
  2006  // add HTTP headers to the request.
  2007  func (c *OperationsGetCall) Header() http.Header {
  2008  	if c.header_ == nil {
  2009  		c.header_ = make(http.Header)
  2010  	}
  2011  	return c.header_
  2012  }
  2013  
  2014  func (c *OperationsGetCall) doRequest(alt string) (*http.Response, error) {
  2015  	reqHeaders := make(http.Header)
  2016  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2017  	for k, v := range c.header_ {
  2018  		reqHeaders[k] = v
  2019  	}
  2020  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2021  	if c.ifNoneMatch_ != "" {
  2022  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2023  	}
  2024  	var body io.Reader = nil
  2025  	c.urlParams_.Set("alt", alt)
  2026  	c.urlParams_.Set("prettyPrint", "false")
  2027  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}")
  2028  	urls += "?" + c.urlParams_.Encode()
  2029  	req, err := http.NewRequest("GET", urls, body)
  2030  	if err != nil {
  2031  		return nil, err
  2032  	}
  2033  	req.Header = reqHeaders
  2034  	googleapi.Expand(req.URL, map[string]string{
  2035  		"name": c.name,
  2036  	})
  2037  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2038  }
  2039  
  2040  // Do executes the "genomics.operations.get" call.
  2041  // Exactly one of *Operation or error will be non-nil. Any non-2xx
  2042  // status code is an error. Response headers are in either
  2043  // *Operation.ServerResponse.Header or (if a response was returned at
  2044  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
  2045  // to check whether the returned error was because
  2046  // http.StatusNotModified was returned.
  2047  func (c *OperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) {
  2048  	gensupport.SetOptions(c.urlParams_, opts...)
  2049  	res, err := c.doRequest("json")
  2050  	if res != nil && res.StatusCode == http.StatusNotModified {
  2051  		if res.Body != nil {
  2052  			res.Body.Close()
  2053  		}
  2054  		return nil, &googleapi.Error{
  2055  			Code:   res.StatusCode,
  2056  			Header: res.Header,
  2057  		}
  2058  	}
  2059  	if err != nil {
  2060  		return nil, err
  2061  	}
  2062  	defer googleapi.CloseBody(res)
  2063  	if err := googleapi.CheckResponse(res); err != nil {
  2064  		return nil, err
  2065  	}
  2066  	ret := &Operation{
  2067  		ServerResponse: googleapi.ServerResponse{
  2068  			Header:         res.Header,
  2069  			HTTPStatusCode: res.StatusCode,
  2070  		},
  2071  	}
  2072  	target := &ret
  2073  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2074  		return nil, err
  2075  	}
  2076  	return ret, nil
  2077  	// {
  2078  	//   "description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Authorization requires the following [Google IAM](https://cloud.google.com/iam) permission: * `genomics.operations.get`",
  2079  	//   "flatPath": "v1alpha2/operations/{operationsId}",
  2080  	//   "httpMethod": "GET",
  2081  	//   "id": "genomics.operations.get",
  2082  	//   "parameterOrder": [
  2083  	//     "name"
  2084  	//   ],
  2085  	//   "parameters": {
  2086  	//     "name": {
  2087  	//       "description": "The name of the operation resource.",
  2088  	//       "location": "path",
  2089  	//       "pattern": "^operations/.*$",
  2090  	//       "required": true,
  2091  	//       "type": "string"
  2092  	//     }
  2093  	//   },
  2094  	//   "path": "v1alpha2/{+name}",
  2095  	//   "response": {
  2096  	//     "$ref": "Operation"
  2097  	//   },
  2098  	//   "scopes": [
  2099  	//     "https://www.googleapis.com/auth/cloud-platform",
  2100  	//     "https://www.googleapis.com/auth/genomics"
  2101  	//   ]
  2102  	// }
  2103  
  2104  }
  2105  
  2106  // method id "genomics.operations.list":
  2107  
  2108  type OperationsListCall struct {
  2109  	s            *Service
  2110  	name         string
  2111  	urlParams_   gensupport.URLParams
  2112  	ifNoneMatch_ string
  2113  	ctx_         context.Context
  2114  	header_      http.Header
  2115  }
  2116  
  2117  // List: Lists operations that match the specified filter in the
  2118  // request. Authorization requires the following Google IAM
  2119  // (https://cloud.google.com/iam) permission: *
  2120  // `genomics.operations.list`
  2121  //
  2122  // - name: The name of the operation's parent resource.
  2123  func (r *OperationsService) List(name string) *OperationsListCall {
  2124  	c := &OperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2125  	c.name = name
  2126  	return c
  2127  }
  2128  
  2129  // Filter sets the optional parameter "filter": A string for filtering
  2130  // Operations. In v2alpha1, the following filter fields are supported: *
  2131  // createTime: The time this job was created * events: The set of event
  2132  // (names) that have occurred while running the pipeline. The : operator
  2133  // can be used to determine if a particular event has occurred. * error:
  2134  // If the pipeline is running, this value is NULL. Once the pipeline
  2135  // finishes, the value is the standard Google error code. * labels.key
  2136  // or labels."key with space" where key is a label key. * done: If the
  2137  // pipeline is running, this value is false. Once the pipeline finishes,
  2138  // the value is true. In v1 and v1alpha2, the following filter fields
  2139  // are supported: * projectId: Required. Corresponds to
  2140  // OperationMetadata.projectId. * createTime: The time this job was
  2141  // created, in seconds from the epoch
  2142  // (http://en.wikipedia.org/wiki/Unix_time). Can use `>=` and/or `<=`
  2143  // operators. * status: Can be `RUNNING`, `SUCCESS`, `FAILURE`, or
  2144  // `CANCELED`. Only one status may be specified. * labels.key where key
  2145  // is a label key. Examples: * `projectId = my-project AND createTime >=
  2146  // 1432140000` * `projectId = my-project AND createTime >= 1432140000
  2147  // AND createTime <= 1432150000 AND status = RUNNING` * `projectId =
  2148  // my-project AND labels.color = *` * `projectId = my-project AND
  2149  // labels.color = red`
  2150  func (c *OperationsListCall) Filter(filter string) *OperationsListCall {
  2151  	c.urlParams_.Set("filter", filter)
  2152  	return c
  2153  }
  2154  
  2155  // PageSize sets the optional parameter "pageSize": The maximum number
  2156  // of results to return. The maximum value is 256.
  2157  func (c *OperationsListCall) PageSize(pageSize int64) *OperationsListCall {
  2158  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  2159  	return c
  2160  }
  2161  
  2162  // PageToken sets the optional parameter "pageToken": The standard list
  2163  // page token.
  2164  func (c *OperationsListCall) PageToken(pageToken string) *OperationsListCall {
  2165  	c.urlParams_.Set("pageToken", pageToken)
  2166  	return c
  2167  }
  2168  
  2169  // Fields allows partial responses to be retrieved. See
  2170  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2171  // for more information.
  2172  func (c *OperationsListCall) Fields(s ...googleapi.Field) *OperationsListCall {
  2173  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2174  	return c
  2175  }
  2176  
  2177  // IfNoneMatch sets the optional parameter which makes the operation
  2178  // fail if the object's ETag matches the given value. This is useful for
  2179  // getting updates only after the object has changed since the last
  2180  // request. Use googleapi.IsNotModified to check whether the response
  2181  // error from Do is the result of In-None-Match.
  2182  func (c *OperationsListCall) IfNoneMatch(entityTag string) *OperationsListCall {
  2183  	c.ifNoneMatch_ = entityTag
  2184  	return c
  2185  }
  2186  
  2187  // Context sets the context to be used in this call's Do method. Any
  2188  // pending HTTP request will be aborted if the provided context is
  2189  // canceled.
  2190  func (c *OperationsListCall) Context(ctx context.Context) *OperationsListCall {
  2191  	c.ctx_ = ctx
  2192  	return c
  2193  }
  2194  
  2195  // Header returns an http.Header that can be modified by the caller to
  2196  // add HTTP headers to the request.
  2197  func (c *OperationsListCall) Header() http.Header {
  2198  	if c.header_ == nil {
  2199  		c.header_ = make(http.Header)
  2200  	}
  2201  	return c.header_
  2202  }
  2203  
  2204  func (c *OperationsListCall) doRequest(alt string) (*http.Response, error) {
  2205  	reqHeaders := make(http.Header)
  2206  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2207  	for k, v := range c.header_ {
  2208  		reqHeaders[k] = v
  2209  	}
  2210  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2211  	if c.ifNoneMatch_ != "" {
  2212  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2213  	}
  2214  	var body io.Reader = nil
  2215  	c.urlParams_.Set("alt", alt)
  2216  	c.urlParams_.Set("prettyPrint", "false")
  2217  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}")
  2218  	urls += "?" + c.urlParams_.Encode()
  2219  	req, err := http.NewRequest("GET", urls, body)
  2220  	if err != nil {
  2221  		return nil, err
  2222  	}
  2223  	req.Header = reqHeaders
  2224  	googleapi.Expand(req.URL, map[string]string{
  2225  		"name": c.name,
  2226  	})
  2227  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2228  }
  2229  
  2230  // Do executes the "genomics.operations.list" call.
  2231  // Exactly one of *ListOperationsResponse or error will be non-nil. Any
  2232  // non-2xx status code is an error. Response headers are in either
  2233  // *ListOperationsResponse.ServerResponse.Header or (if a response was
  2234  // returned at all) in error.(*googleapi.Error).Header. Use
  2235  // googleapi.IsNotModified to check whether the returned error was
  2236  // because http.StatusNotModified was returned.
  2237  func (c *OperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) {
  2238  	gensupport.SetOptions(c.urlParams_, opts...)
  2239  	res, err := c.doRequest("json")
  2240  	if res != nil && res.StatusCode == http.StatusNotModified {
  2241  		if res.Body != nil {
  2242  			res.Body.Close()
  2243  		}
  2244  		return nil, &googleapi.Error{
  2245  			Code:   res.StatusCode,
  2246  			Header: res.Header,
  2247  		}
  2248  	}
  2249  	if err != nil {
  2250  		return nil, err
  2251  	}
  2252  	defer googleapi.CloseBody(res)
  2253  	if err := googleapi.CheckResponse(res); err != nil {
  2254  		return nil, err
  2255  	}
  2256  	ret := &ListOperationsResponse{
  2257  		ServerResponse: googleapi.ServerResponse{
  2258  			Header:         res.Header,
  2259  			HTTPStatusCode: res.StatusCode,
  2260  		},
  2261  	}
  2262  	target := &ret
  2263  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2264  		return nil, err
  2265  	}
  2266  	return ret, nil
  2267  	// {
  2268  	//   "description": "Lists operations that match the specified filter in the request. Authorization requires the following [Google IAM](https://cloud.google.com/iam) permission: * `genomics.operations.list`",
  2269  	//   "flatPath": "v1alpha2/operations",
  2270  	//   "httpMethod": "GET",
  2271  	//   "id": "genomics.operations.list",
  2272  	//   "parameterOrder": [
  2273  	//     "name"
  2274  	//   ],
  2275  	//   "parameters": {
  2276  	//     "filter": {
  2277  	//       "description": "A string for filtering Operations. In v2alpha1, the following filter fields are supported: * createTime: The time this job was created * events: The set of event (names) that have occurred while running the pipeline. The : operator can be used to determine if a particular event has occurred. * error: If the pipeline is running, this value is NULL. Once the pipeline finishes, the value is the standard Google error code. * labels.key or labels.\"key with space\" where key is a label key. * done: If the pipeline is running, this value is false. Once the pipeline finishes, the value is true. In v1 and v1alpha2, the following filter fields are supported: * projectId: Required. Corresponds to OperationMetadata.projectId. * createTime: The time this job was created, in seconds from the [epoch](http://en.wikipedia.org/wiki/Unix_time). Can use `\u003e=` and/or `\u003c=` operators. * status: Can be `RUNNING`, `SUCCESS`, `FAILURE`, or `CANCELED`. Only one status may be specified. * labels.key where key is a label key. Examples: * `projectId = my-project AND createTime \u003e= 1432140000` * `projectId = my-project AND createTime \u003e= 1432140000 AND createTime \u003c= 1432150000 AND status = RUNNING` * `projectId = my-project AND labels.color = *` * `projectId = my-project AND labels.color = red`",
  2278  	//       "location": "query",
  2279  	//       "type": "string"
  2280  	//     },
  2281  	//     "name": {
  2282  	//       "description": "The name of the operation's parent resource.",
  2283  	//       "location": "path",
  2284  	//       "pattern": "^operations$",
  2285  	//       "required": true,
  2286  	//       "type": "string"
  2287  	//     },
  2288  	//     "pageSize": {
  2289  	//       "description": "The maximum number of results to return. The maximum value is 256.",
  2290  	//       "format": "int32",
  2291  	//       "location": "query",
  2292  	//       "type": "integer"
  2293  	//     },
  2294  	//     "pageToken": {
  2295  	//       "description": "The standard list page token.",
  2296  	//       "location": "query",
  2297  	//       "type": "string"
  2298  	//     }
  2299  	//   },
  2300  	//   "path": "v1alpha2/{+name}",
  2301  	//   "response": {
  2302  	//     "$ref": "ListOperationsResponse"
  2303  	//   },
  2304  	//   "scopes": [
  2305  	//     "https://www.googleapis.com/auth/cloud-platform",
  2306  	//     "https://www.googleapis.com/auth/genomics"
  2307  	//   ]
  2308  	// }
  2309  
  2310  }
  2311  
  2312  // Pages invokes f for each page of results.
  2313  // A non-nil error returned from f will halt the iteration.
  2314  // The provided context supersedes any context provided to the Context method.
  2315  func (c *OperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error {
  2316  	c.ctx_ = ctx
  2317  	defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
  2318  	for {
  2319  		x, err := c.Do()
  2320  		if err != nil {
  2321  			return err
  2322  		}
  2323  		if err := f(x); err != nil {
  2324  			return err
  2325  		}
  2326  		if x.NextPageToken == "" {
  2327  			return nil
  2328  		}
  2329  		c.PageToken(x.NextPageToken)
  2330  	}
  2331  }
  2332  
  2333  // method id "genomics.pipelines.create":
  2334  
  2335  type PipelinesCreateCall struct {
  2336  	s          *Service
  2337  	pipeline   *Pipeline
  2338  	urlParams_ gensupport.URLParams
  2339  	ctx_       context.Context
  2340  	header_    http.Header
  2341  }
  2342  
  2343  // Create: Creates a pipeline that can be run later. Create takes a
  2344  // Pipeline that has all fields other than `pipelineId` populated, and
  2345  // then returns the same pipeline with `pipelineId` populated. This id
  2346  // can be used to run the pipeline. Caller must have WRITE permission to
  2347  // the project.
  2348  func (r *PipelinesService) Create(pipeline *Pipeline) *PipelinesCreateCall {
  2349  	c := &PipelinesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2350  	c.pipeline = pipeline
  2351  	return c
  2352  }
  2353  
  2354  // Fields allows partial responses to be retrieved. See
  2355  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2356  // for more information.
  2357  func (c *PipelinesCreateCall) Fields(s ...googleapi.Field) *PipelinesCreateCall {
  2358  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2359  	return c
  2360  }
  2361  
  2362  // Context sets the context to be used in this call's Do method. Any
  2363  // pending HTTP request will be aborted if the provided context is
  2364  // canceled.
  2365  func (c *PipelinesCreateCall) Context(ctx context.Context) *PipelinesCreateCall {
  2366  	c.ctx_ = ctx
  2367  	return c
  2368  }
  2369  
  2370  // Header returns an http.Header that can be modified by the caller to
  2371  // add HTTP headers to the request.
  2372  func (c *PipelinesCreateCall) Header() http.Header {
  2373  	if c.header_ == nil {
  2374  		c.header_ = make(http.Header)
  2375  	}
  2376  	return c.header_
  2377  }
  2378  
  2379  func (c *PipelinesCreateCall) doRequest(alt string) (*http.Response, error) {
  2380  	reqHeaders := make(http.Header)
  2381  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2382  	for k, v := range c.header_ {
  2383  		reqHeaders[k] = v
  2384  	}
  2385  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2386  	var body io.Reader = nil
  2387  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.pipeline)
  2388  	if err != nil {
  2389  		return nil, err
  2390  	}
  2391  	reqHeaders.Set("Content-Type", "application/json")
  2392  	c.urlParams_.Set("alt", alt)
  2393  	c.urlParams_.Set("prettyPrint", "false")
  2394  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines")
  2395  	urls += "?" + c.urlParams_.Encode()
  2396  	req, err := http.NewRequest("POST", urls, body)
  2397  	if err != nil {
  2398  		return nil, err
  2399  	}
  2400  	req.Header = reqHeaders
  2401  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2402  }
  2403  
  2404  // Do executes the "genomics.pipelines.create" call.
  2405  // Exactly one of *Pipeline or error will be non-nil. Any non-2xx status
  2406  // code is an error. Response headers are in either
  2407  // *Pipeline.ServerResponse.Header or (if a response was returned at
  2408  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
  2409  // to check whether the returned error was because
  2410  // http.StatusNotModified was returned.
  2411  func (c *PipelinesCreateCall) Do(opts ...googleapi.CallOption) (*Pipeline, error) {
  2412  	gensupport.SetOptions(c.urlParams_, opts...)
  2413  	res, err := c.doRequest("json")
  2414  	if res != nil && res.StatusCode == http.StatusNotModified {
  2415  		if res.Body != nil {
  2416  			res.Body.Close()
  2417  		}
  2418  		return nil, &googleapi.Error{
  2419  			Code:   res.StatusCode,
  2420  			Header: res.Header,
  2421  		}
  2422  	}
  2423  	if err != nil {
  2424  		return nil, err
  2425  	}
  2426  	defer googleapi.CloseBody(res)
  2427  	if err := googleapi.CheckResponse(res); err != nil {
  2428  		return nil, err
  2429  	}
  2430  	ret := &Pipeline{
  2431  		ServerResponse: googleapi.ServerResponse{
  2432  			Header:         res.Header,
  2433  			HTTPStatusCode: res.StatusCode,
  2434  		},
  2435  	}
  2436  	target := &ret
  2437  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2438  		return nil, err
  2439  	}
  2440  	return ret, nil
  2441  	// {
  2442  	//   "description": "Creates a pipeline that can be run later. Create takes a Pipeline that has all fields other than `pipelineId` populated, and then returns the same pipeline with `pipelineId` populated. This id can be used to run the pipeline. Caller must have WRITE permission to the project.",
  2443  	//   "flatPath": "v1alpha2/pipelines",
  2444  	//   "httpMethod": "POST",
  2445  	//   "id": "genomics.pipelines.create",
  2446  	//   "parameterOrder": [],
  2447  	//   "parameters": {},
  2448  	//   "path": "v1alpha2/pipelines",
  2449  	//   "request": {
  2450  	//     "$ref": "Pipeline"
  2451  	//   },
  2452  	//   "response": {
  2453  	//     "$ref": "Pipeline"
  2454  	//   },
  2455  	//   "scopes": [
  2456  	//     "https://www.googleapis.com/auth/cloud-platform",
  2457  	//     "https://www.googleapis.com/auth/genomics"
  2458  	//   ]
  2459  	// }
  2460  
  2461  }
  2462  
  2463  // method id "genomics.pipelines.delete":
  2464  
  2465  type PipelinesDeleteCall struct {
  2466  	s          *Service
  2467  	pipelineId string
  2468  	urlParams_ gensupport.URLParams
  2469  	ctx_       context.Context
  2470  	header_    http.Header
  2471  }
  2472  
  2473  // Delete: Deletes a pipeline based on ID. Caller must have WRITE
  2474  // permission to the project.
  2475  //
  2476  //   - pipelineId: Caller must have WRITE access to the project in which
  2477  //     this pipeline is defined.
  2478  func (r *PipelinesService) Delete(pipelineId string) *PipelinesDeleteCall {
  2479  	c := &PipelinesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2480  	c.pipelineId = pipelineId
  2481  	return c
  2482  }
  2483  
  2484  // Fields allows partial responses to be retrieved. See
  2485  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2486  // for more information.
  2487  func (c *PipelinesDeleteCall) Fields(s ...googleapi.Field) *PipelinesDeleteCall {
  2488  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2489  	return c
  2490  }
  2491  
  2492  // Context sets the context to be used in this call's Do method. Any
  2493  // pending HTTP request will be aborted if the provided context is
  2494  // canceled.
  2495  func (c *PipelinesDeleteCall) Context(ctx context.Context) *PipelinesDeleteCall {
  2496  	c.ctx_ = ctx
  2497  	return c
  2498  }
  2499  
  2500  // Header returns an http.Header that can be modified by the caller to
  2501  // add HTTP headers to the request.
  2502  func (c *PipelinesDeleteCall) Header() http.Header {
  2503  	if c.header_ == nil {
  2504  		c.header_ = make(http.Header)
  2505  	}
  2506  	return c.header_
  2507  }
  2508  
  2509  func (c *PipelinesDeleteCall) doRequest(alt string) (*http.Response, error) {
  2510  	reqHeaders := make(http.Header)
  2511  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2512  	for k, v := range c.header_ {
  2513  		reqHeaders[k] = v
  2514  	}
  2515  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2516  	var body io.Reader = nil
  2517  	c.urlParams_.Set("alt", alt)
  2518  	c.urlParams_.Set("prettyPrint", "false")
  2519  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines/{pipelineId}")
  2520  	urls += "?" + c.urlParams_.Encode()
  2521  	req, err := http.NewRequest("DELETE", urls, body)
  2522  	if err != nil {
  2523  		return nil, err
  2524  	}
  2525  	req.Header = reqHeaders
  2526  	googleapi.Expand(req.URL, map[string]string{
  2527  		"pipelineId": c.pipelineId,
  2528  	})
  2529  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2530  }
  2531  
  2532  // Do executes the "genomics.pipelines.delete" call.
  2533  // Exactly one of *Empty or error will be non-nil. Any non-2xx status
  2534  // code is an error. Response headers are in either
  2535  // *Empty.ServerResponse.Header or (if a response was returned at all)
  2536  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2537  // check whether the returned error was because http.StatusNotModified
  2538  // was returned.
  2539  func (c *PipelinesDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  2540  	gensupport.SetOptions(c.urlParams_, opts...)
  2541  	res, err := c.doRequest("json")
  2542  	if res != nil && res.StatusCode == http.StatusNotModified {
  2543  		if res.Body != nil {
  2544  			res.Body.Close()
  2545  		}
  2546  		return nil, &googleapi.Error{
  2547  			Code:   res.StatusCode,
  2548  			Header: res.Header,
  2549  		}
  2550  	}
  2551  	if err != nil {
  2552  		return nil, err
  2553  	}
  2554  	defer googleapi.CloseBody(res)
  2555  	if err := googleapi.CheckResponse(res); err != nil {
  2556  		return nil, err
  2557  	}
  2558  	ret := &Empty{
  2559  		ServerResponse: googleapi.ServerResponse{
  2560  			Header:         res.Header,
  2561  			HTTPStatusCode: res.StatusCode,
  2562  		},
  2563  	}
  2564  	target := &ret
  2565  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2566  		return nil, err
  2567  	}
  2568  	return ret, nil
  2569  	// {
  2570  	//   "description": "Deletes a pipeline based on ID. Caller must have WRITE permission to the project.",
  2571  	//   "flatPath": "v1alpha2/pipelines/{pipelineId}",
  2572  	//   "httpMethod": "DELETE",
  2573  	//   "id": "genomics.pipelines.delete",
  2574  	//   "parameterOrder": [
  2575  	//     "pipelineId"
  2576  	//   ],
  2577  	//   "parameters": {
  2578  	//     "pipelineId": {
  2579  	//       "description": "Caller must have WRITE access to the project in which this pipeline is defined.",
  2580  	//       "location": "path",
  2581  	//       "required": true,
  2582  	//       "type": "string"
  2583  	//     }
  2584  	//   },
  2585  	//   "path": "v1alpha2/pipelines/{pipelineId}",
  2586  	//   "response": {
  2587  	//     "$ref": "Empty"
  2588  	//   },
  2589  	//   "scopes": [
  2590  	//     "https://www.googleapis.com/auth/cloud-platform",
  2591  	//     "https://www.googleapis.com/auth/genomics"
  2592  	//   ]
  2593  	// }
  2594  
  2595  }
  2596  
  2597  // method id "genomics.pipelines.get":
  2598  
  2599  type PipelinesGetCall struct {
  2600  	s            *Service
  2601  	pipelineId   string
  2602  	urlParams_   gensupport.URLParams
  2603  	ifNoneMatch_ string
  2604  	ctx_         context.Context
  2605  	header_      http.Header
  2606  }
  2607  
  2608  // Get: Retrieves a pipeline based on ID. Caller must have READ
  2609  // permission to the project.
  2610  //
  2611  //   - pipelineId: Caller must have READ access to the project in which
  2612  //     this pipeline is defined.
  2613  func (r *PipelinesService) Get(pipelineId string) *PipelinesGetCall {
  2614  	c := &PipelinesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2615  	c.pipelineId = pipelineId
  2616  	return c
  2617  }
  2618  
  2619  // Fields allows partial responses to be retrieved. See
  2620  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2621  // for more information.
  2622  func (c *PipelinesGetCall) Fields(s ...googleapi.Field) *PipelinesGetCall {
  2623  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2624  	return c
  2625  }
  2626  
  2627  // IfNoneMatch sets the optional parameter which makes the operation
  2628  // fail if the object's ETag matches the given value. This is useful for
  2629  // getting updates only after the object has changed since the last
  2630  // request. Use googleapi.IsNotModified to check whether the response
  2631  // error from Do is the result of In-None-Match.
  2632  func (c *PipelinesGetCall) IfNoneMatch(entityTag string) *PipelinesGetCall {
  2633  	c.ifNoneMatch_ = entityTag
  2634  	return c
  2635  }
  2636  
  2637  // Context sets the context to be used in this call's Do method. Any
  2638  // pending HTTP request will be aborted if the provided context is
  2639  // canceled.
  2640  func (c *PipelinesGetCall) Context(ctx context.Context) *PipelinesGetCall {
  2641  	c.ctx_ = ctx
  2642  	return c
  2643  }
  2644  
  2645  // Header returns an http.Header that can be modified by the caller to
  2646  // add HTTP headers to the request.
  2647  func (c *PipelinesGetCall) Header() http.Header {
  2648  	if c.header_ == nil {
  2649  		c.header_ = make(http.Header)
  2650  	}
  2651  	return c.header_
  2652  }
  2653  
  2654  func (c *PipelinesGetCall) doRequest(alt string) (*http.Response, error) {
  2655  	reqHeaders := make(http.Header)
  2656  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2657  	for k, v := range c.header_ {
  2658  		reqHeaders[k] = v
  2659  	}
  2660  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2661  	if c.ifNoneMatch_ != "" {
  2662  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2663  	}
  2664  	var body io.Reader = nil
  2665  	c.urlParams_.Set("alt", alt)
  2666  	c.urlParams_.Set("prettyPrint", "false")
  2667  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines/{pipelineId}")
  2668  	urls += "?" + c.urlParams_.Encode()
  2669  	req, err := http.NewRequest("GET", urls, body)
  2670  	if err != nil {
  2671  		return nil, err
  2672  	}
  2673  	req.Header = reqHeaders
  2674  	googleapi.Expand(req.URL, map[string]string{
  2675  		"pipelineId": c.pipelineId,
  2676  	})
  2677  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2678  }
  2679  
  2680  // Do executes the "genomics.pipelines.get" call.
  2681  // Exactly one of *Pipeline or error will be non-nil. Any non-2xx status
  2682  // code is an error. Response headers are in either
  2683  // *Pipeline.ServerResponse.Header or (if a response was returned at
  2684  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
  2685  // to check whether the returned error was because
  2686  // http.StatusNotModified was returned.
  2687  func (c *PipelinesGetCall) Do(opts ...googleapi.CallOption) (*Pipeline, error) {
  2688  	gensupport.SetOptions(c.urlParams_, opts...)
  2689  	res, err := c.doRequest("json")
  2690  	if res != nil && res.StatusCode == http.StatusNotModified {
  2691  		if res.Body != nil {
  2692  			res.Body.Close()
  2693  		}
  2694  		return nil, &googleapi.Error{
  2695  			Code:   res.StatusCode,
  2696  			Header: res.Header,
  2697  		}
  2698  	}
  2699  	if err != nil {
  2700  		return nil, err
  2701  	}
  2702  	defer googleapi.CloseBody(res)
  2703  	if err := googleapi.CheckResponse(res); err != nil {
  2704  		return nil, err
  2705  	}
  2706  	ret := &Pipeline{
  2707  		ServerResponse: googleapi.ServerResponse{
  2708  			Header:         res.Header,
  2709  			HTTPStatusCode: res.StatusCode,
  2710  		},
  2711  	}
  2712  	target := &ret
  2713  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2714  		return nil, err
  2715  	}
  2716  	return ret, nil
  2717  	// {
  2718  	//   "description": "Retrieves a pipeline based on ID. Caller must have READ permission to the project.",
  2719  	//   "flatPath": "v1alpha2/pipelines/{pipelineId}",
  2720  	//   "httpMethod": "GET",
  2721  	//   "id": "genomics.pipelines.get",
  2722  	//   "parameterOrder": [
  2723  	//     "pipelineId"
  2724  	//   ],
  2725  	//   "parameters": {
  2726  	//     "pipelineId": {
  2727  	//       "description": "Caller must have READ access to the project in which this pipeline is defined.",
  2728  	//       "location": "path",
  2729  	//       "required": true,
  2730  	//       "type": "string"
  2731  	//     }
  2732  	//   },
  2733  	//   "path": "v1alpha2/pipelines/{pipelineId}",
  2734  	//   "response": {
  2735  	//     "$ref": "Pipeline"
  2736  	//   },
  2737  	//   "scopes": [
  2738  	//     "https://www.googleapis.com/auth/cloud-platform",
  2739  	//     "https://www.googleapis.com/auth/genomics"
  2740  	//   ]
  2741  	// }
  2742  
  2743  }
  2744  
  2745  // method id "genomics.pipelines.getControllerConfig":
  2746  
  2747  type PipelinesGetControllerConfigCall struct {
  2748  	s            *Service
  2749  	urlParams_   gensupport.URLParams
  2750  	ifNoneMatch_ string
  2751  	ctx_         context.Context
  2752  	header_      http.Header
  2753  }
  2754  
  2755  // GetControllerConfig: Gets controller configuration information.
  2756  // Should only be called by VMs created by the Pipelines Service and not
  2757  // by end users.
  2758  func (r *PipelinesService) GetControllerConfig() *PipelinesGetControllerConfigCall {
  2759  	c := &PipelinesGetControllerConfigCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2760  	return c
  2761  }
  2762  
  2763  // OperationId sets the optional parameter "operationId": The operation
  2764  // to retrieve controller configuration for.
  2765  func (c *PipelinesGetControllerConfigCall) OperationId(operationId string) *PipelinesGetControllerConfigCall {
  2766  	c.urlParams_.Set("operationId", operationId)
  2767  	return c
  2768  }
  2769  
  2770  // ValidationToken sets the optional parameter "validationToken":
  2771  func (c *PipelinesGetControllerConfigCall) ValidationToken(validationToken uint64) *PipelinesGetControllerConfigCall {
  2772  	c.urlParams_.Set("validationToken", fmt.Sprint(validationToken))
  2773  	return c
  2774  }
  2775  
  2776  // Fields allows partial responses to be retrieved. See
  2777  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2778  // for more information.
  2779  func (c *PipelinesGetControllerConfigCall) Fields(s ...googleapi.Field) *PipelinesGetControllerConfigCall {
  2780  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2781  	return c
  2782  }
  2783  
  2784  // IfNoneMatch sets the optional parameter which makes the operation
  2785  // fail if the object's ETag matches the given value. This is useful for
  2786  // getting updates only after the object has changed since the last
  2787  // request. Use googleapi.IsNotModified to check whether the response
  2788  // error from Do is the result of In-None-Match.
  2789  func (c *PipelinesGetControllerConfigCall) IfNoneMatch(entityTag string) *PipelinesGetControllerConfigCall {
  2790  	c.ifNoneMatch_ = entityTag
  2791  	return c
  2792  }
  2793  
  2794  // Context sets the context to be used in this call's Do method. Any
  2795  // pending HTTP request will be aborted if the provided context is
  2796  // canceled.
  2797  func (c *PipelinesGetControllerConfigCall) Context(ctx context.Context) *PipelinesGetControllerConfigCall {
  2798  	c.ctx_ = ctx
  2799  	return c
  2800  }
  2801  
  2802  // Header returns an http.Header that can be modified by the caller to
  2803  // add HTTP headers to the request.
  2804  func (c *PipelinesGetControllerConfigCall) Header() http.Header {
  2805  	if c.header_ == nil {
  2806  		c.header_ = make(http.Header)
  2807  	}
  2808  	return c.header_
  2809  }
  2810  
  2811  func (c *PipelinesGetControllerConfigCall) doRequest(alt string) (*http.Response, error) {
  2812  	reqHeaders := make(http.Header)
  2813  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2814  	for k, v := range c.header_ {
  2815  		reqHeaders[k] = v
  2816  	}
  2817  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2818  	if c.ifNoneMatch_ != "" {
  2819  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2820  	}
  2821  	var body io.Reader = nil
  2822  	c.urlParams_.Set("alt", alt)
  2823  	c.urlParams_.Set("prettyPrint", "false")
  2824  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines:getControllerConfig")
  2825  	urls += "?" + c.urlParams_.Encode()
  2826  	req, err := http.NewRequest("GET", urls, body)
  2827  	if err != nil {
  2828  		return nil, err
  2829  	}
  2830  	req.Header = reqHeaders
  2831  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2832  }
  2833  
  2834  // Do executes the "genomics.pipelines.getControllerConfig" call.
  2835  // Exactly one of *ControllerConfig or error will be non-nil. Any
  2836  // non-2xx status code is an error. Response headers are in either
  2837  // *ControllerConfig.ServerResponse.Header or (if a response was
  2838  // returned at all) in error.(*googleapi.Error).Header. Use
  2839  // googleapi.IsNotModified to check whether the returned error was
  2840  // because http.StatusNotModified was returned.
  2841  func (c *PipelinesGetControllerConfigCall) Do(opts ...googleapi.CallOption) (*ControllerConfig, error) {
  2842  	gensupport.SetOptions(c.urlParams_, opts...)
  2843  	res, err := c.doRequest("json")
  2844  	if res != nil && res.StatusCode == http.StatusNotModified {
  2845  		if res.Body != nil {
  2846  			res.Body.Close()
  2847  		}
  2848  		return nil, &googleapi.Error{
  2849  			Code:   res.StatusCode,
  2850  			Header: res.Header,
  2851  		}
  2852  	}
  2853  	if err != nil {
  2854  		return nil, err
  2855  	}
  2856  	defer googleapi.CloseBody(res)
  2857  	if err := googleapi.CheckResponse(res); err != nil {
  2858  		return nil, err
  2859  	}
  2860  	ret := &ControllerConfig{
  2861  		ServerResponse: googleapi.ServerResponse{
  2862  			Header:         res.Header,
  2863  			HTTPStatusCode: res.StatusCode,
  2864  		},
  2865  	}
  2866  	target := &ret
  2867  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2868  		return nil, err
  2869  	}
  2870  	return ret, nil
  2871  	// {
  2872  	//   "description": "Gets controller configuration information. Should only be called by VMs created by the Pipelines Service and not by end users.",
  2873  	//   "flatPath": "v1alpha2/pipelines:getControllerConfig",
  2874  	//   "httpMethod": "GET",
  2875  	//   "id": "genomics.pipelines.getControllerConfig",
  2876  	//   "parameterOrder": [],
  2877  	//   "parameters": {
  2878  	//     "operationId": {
  2879  	//       "description": "The operation to retrieve controller configuration for.",
  2880  	//       "location": "query",
  2881  	//       "type": "string"
  2882  	//     },
  2883  	//     "validationToken": {
  2884  	//       "format": "uint64",
  2885  	//       "location": "query",
  2886  	//       "type": "string"
  2887  	//     }
  2888  	//   },
  2889  	//   "path": "v1alpha2/pipelines:getControllerConfig",
  2890  	//   "response": {
  2891  	//     "$ref": "ControllerConfig"
  2892  	//   },
  2893  	//   "scopes": [
  2894  	//     "https://www.googleapis.com/auth/cloud-platform",
  2895  	//     "https://www.googleapis.com/auth/genomics"
  2896  	//   ]
  2897  	// }
  2898  
  2899  }
  2900  
  2901  // method id "genomics.pipelines.list":
  2902  
  2903  type PipelinesListCall struct {
  2904  	s            *Service
  2905  	urlParams_   gensupport.URLParams
  2906  	ifNoneMatch_ string
  2907  	ctx_         context.Context
  2908  	header_      http.Header
  2909  }
  2910  
  2911  // List: Lists pipelines. Caller must have READ permission to the
  2912  // project.
  2913  func (r *PipelinesService) List() *PipelinesListCall {
  2914  	c := &PipelinesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2915  	return c
  2916  }
  2917  
  2918  // NamePrefix sets the optional parameter "namePrefix": Pipelines with
  2919  // names that match this prefix should be returned. If unspecified, all
  2920  // pipelines in the project, up to `pageSize`, will be returned.
  2921  func (c *PipelinesListCall) NamePrefix(namePrefix string) *PipelinesListCall {
  2922  	c.urlParams_.Set("namePrefix", namePrefix)
  2923  	return c
  2924  }
  2925  
  2926  // PageSize sets the optional parameter "pageSize": Number of pipelines
  2927  // to return at once. Defaults to 256, and max is 2048.
  2928  func (c *PipelinesListCall) PageSize(pageSize int64) *PipelinesListCall {
  2929  	c.urlParams_.Set("pageSize", fmt.Sprint(pageSize))
  2930  	return c
  2931  }
  2932  
  2933  // PageToken sets the optional parameter "pageToken": Token to use to
  2934  // indicate where to start getting results. If unspecified, returns the
  2935  // first page of results.
  2936  func (c *PipelinesListCall) PageToken(pageToken string) *PipelinesListCall {
  2937  	c.urlParams_.Set("pageToken", pageToken)
  2938  	return c
  2939  }
  2940  
  2941  // ProjectId sets the optional parameter "projectId": Required. The name
  2942  // of the project to search for pipelines. Caller must have READ access
  2943  // to this project.
  2944  func (c *PipelinesListCall) ProjectId(projectId string) *PipelinesListCall {
  2945  	c.urlParams_.Set("projectId", projectId)
  2946  	return c
  2947  }
  2948  
  2949  // Fields allows partial responses to be retrieved. See
  2950  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2951  // for more information.
  2952  func (c *PipelinesListCall) Fields(s ...googleapi.Field) *PipelinesListCall {
  2953  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2954  	return c
  2955  }
  2956  
  2957  // IfNoneMatch sets the optional parameter which makes the operation
  2958  // fail if the object's ETag matches the given value. This is useful for
  2959  // getting updates only after the object has changed since the last
  2960  // request. Use googleapi.IsNotModified to check whether the response
  2961  // error from Do is the result of In-None-Match.
  2962  func (c *PipelinesListCall) IfNoneMatch(entityTag string) *PipelinesListCall {
  2963  	c.ifNoneMatch_ = entityTag
  2964  	return c
  2965  }
  2966  
  2967  // Context sets the context to be used in this call's Do method. Any
  2968  // pending HTTP request will be aborted if the provided context is
  2969  // canceled.
  2970  func (c *PipelinesListCall) Context(ctx context.Context) *PipelinesListCall {
  2971  	c.ctx_ = ctx
  2972  	return c
  2973  }
  2974  
  2975  // Header returns an http.Header that can be modified by the caller to
  2976  // add HTTP headers to the request.
  2977  func (c *PipelinesListCall) Header() http.Header {
  2978  	if c.header_ == nil {
  2979  		c.header_ = make(http.Header)
  2980  	}
  2981  	return c.header_
  2982  }
  2983  
  2984  func (c *PipelinesListCall) doRequest(alt string) (*http.Response, error) {
  2985  	reqHeaders := make(http.Header)
  2986  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  2987  	for k, v := range c.header_ {
  2988  		reqHeaders[k] = v
  2989  	}
  2990  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2991  	if c.ifNoneMatch_ != "" {
  2992  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2993  	}
  2994  	var body io.Reader = nil
  2995  	c.urlParams_.Set("alt", alt)
  2996  	c.urlParams_.Set("prettyPrint", "false")
  2997  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines")
  2998  	urls += "?" + c.urlParams_.Encode()
  2999  	req, err := http.NewRequest("GET", urls, body)
  3000  	if err != nil {
  3001  		return nil, err
  3002  	}
  3003  	req.Header = reqHeaders
  3004  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3005  }
  3006  
  3007  // Do executes the "genomics.pipelines.list" call.
  3008  // Exactly one of *ListPipelinesResponse or error will be non-nil. Any
  3009  // non-2xx status code is an error. Response headers are in either
  3010  // *ListPipelinesResponse.ServerResponse.Header or (if a response was
  3011  // returned at all) in error.(*googleapi.Error).Header. Use
  3012  // googleapi.IsNotModified to check whether the returned error was
  3013  // because http.StatusNotModified was returned.
  3014  func (c *PipelinesListCall) Do(opts ...googleapi.CallOption) (*ListPipelinesResponse, error) {
  3015  	gensupport.SetOptions(c.urlParams_, opts...)
  3016  	res, err := c.doRequest("json")
  3017  	if res != nil && res.StatusCode == http.StatusNotModified {
  3018  		if res.Body != nil {
  3019  			res.Body.Close()
  3020  		}
  3021  		return nil, &googleapi.Error{
  3022  			Code:   res.StatusCode,
  3023  			Header: res.Header,
  3024  		}
  3025  	}
  3026  	if err != nil {
  3027  		return nil, err
  3028  	}
  3029  	defer googleapi.CloseBody(res)
  3030  	if err := googleapi.CheckResponse(res); err != nil {
  3031  		return nil, err
  3032  	}
  3033  	ret := &ListPipelinesResponse{
  3034  		ServerResponse: googleapi.ServerResponse{
  3035  			Header:         res.Header,
  3036  			HTTPStatusCode: res.StatusCode,
  3037  		},
  3038  	}
  3039  	target := &ret
  3040  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3041  		return nil, err
  3042  	}
  3043  	return ret, nil
  3044  	// {
  3045  	//   "description": "Lists pipelines. Caller must have READ permission to the project.",
  3046  	//   "flatPath": "v1alpha2/pipelines",
  3047  	//   "httpMethod": "GET",
  3048  	//   "id": "genomics.pipelines.list",
  3049  	//   "parameterOrder": [],
  3050  	//   "parameters": {
  3051  	//     "namePrefix": {
  3052  	//       "description": "Pipelines with names that match this prefix should be returned. If unspecified, all pipelines in the project, up to `pageSize`, will be returned.",
  3053  	//       "location": "query",
  3054  	//       "type": "string"
  3055  	//     },
  3056  	//     "pageSize": {
  3057  	//       "description": "Number of pipelines to return at once. Defaults to 256, and max is 2048.",
  3058  	//       "format": "int32",
  3059  	//       "location": "query",
  3060  	//       "type": "integer"
  3061  	//     },
  3062  	//     "pageToken": {
  3063  	//       "description": "Token to use to indicate where to start getting results. If unspecified, returns the first page of results.",
  3064  	//       "location": "query",
  3065  	//       "type": "string"
  3066  	//     },
  3067  	//     "projectId": {
  3068  	//       "description": "Required. The name of the project to search for pipelines. Caller must have READ access to this project.",
  3069  	//       "location": "query",
  3070  	//       "type": "string"
  3071  	//     }
  3072  	//   },
  3073  	//   "path": "v1alpha2/pipelines",
  3074  	//   "response": {
  3075  	//     "$ref": "ListPipelinesResponse"
  3076  	//   },
  3077  	//   "scopes": [
  3078  	//     "https://www.googleapis.com/auth/cloud-platform",
  3079  	//     "https://www.googleapis.com/auth/genomics"
  3080  	//   ]
  3081  	// }
  3082  
  3083  }
  3084  
  3085  // Pages invokes f for each page of results.
  3086  // A non-nil error returned from f will halt the iteration.
  3087  // The provided context supersedes any context provided to the Context method.
  3088  func (c *PipelinesListCall) Pages(ctx context.Context, f func(*ListPipelinesResponse) error) error {
  3089  	c.ctx_ = ctx
  3090  	defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point
  3091  	for {
  3092  		x, err := c.Do()
  3093  		if err != nil {
  3094  			return err
  3095  		}
  3096  		if err := f(x); err != nil {
  3097  			return err
  3098  		}
  3099  		if x.NextPageToken == "" {
  3100  			return nil
  3101  		}
  3102  		c.PageToken(x.NextPageToken)
  3103  	}
  3104  }
  3105  
  3106  // method id "genomics.pipelines.run":
  3107  
  3108  type PipelinesRunCall struct {
  3109  	s                  *Service
  3110  	runpipelinerequest *RunPipelineRequest
  3111  	urlParams_         gensupport.URLParams
  3112  	ctx_               context.Context
  3113  	header_            http.Header
  3114  }
  3115  
  3116  // Run: Runs a pipeline. If `pipelineId` is specified in the request,
  3117  // then run a saved pipeline. If `ephemeralPipeline` is specified, then
  3118  // run that pipeline once without saving a copy. The caller must have
  3119  // READ permission to the project where the pipeline is stored and WRITE
  3120  // permission to the project where the pipeline will be run, as VMs will
  3121  // be created and storage will be used. If a pipeline operation is still
  3122  // running after 6 days, it will be canceled.
  3123  func (r *PipelinesService) Run(runpipelinerequest *RunPipelineRequest) *PipelinesRunCall {
  3124  	c := &PipelinesRunCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3125  	c.runpipelinerequest = runpipelinerequest
  3126  	return c
  3127  }
  3128  
  3129  // Fields allows partial responses to be retrieved. See
  3130  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  3131  // for more information.
  3132  func (c *PipelinesRunCall) Fields(s ...googleapi.Field) *PipelinesRunCall {
  3133  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3134  	return c
  3135  }
  3136  
  3137  // Context sets the context to be used in this call's Do method. Any
  3138  // pending HTTP request will be aborted if the provided context is
  3139  // canceled.
  3140  func (c *PipelinesRunCall) Context(ctx context.Context) *PipelinesRunCall {
  3141  	c.ctx_ = ctx
  3142  	return c
  3143  }
  3144  
  3145  // Header returns an http.Header that can be modified by the caller to
  3146  // add HTTP headers to the request.
  3147  func (c *PipelinesRunCall) Header() http.Header {
  3148  	if c.header_ == nil {
  3149  		c.header_ = make(http.Header)
  3150  	}
  3151  	return c.header_
  3152  }
  3153  
  3154  func (c *PipelinesRunCall) doRequest(alt string) (*http.Response, error) {
  3155  	reqHeaders := make(http.Header)
  3156  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  3157  	for k, v := range c.header_ {
  3158  		reqHeaders[k] = v
  3159  	}
  3160  	reqHeaders.Set("User-Agent", c.s.userAgent())
  3161  	var body io.Reader = nil
  3162  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.runpipelinerequest)
  3163  	if err != nil {
  3164  		return nil, err
  3165  	}
  3166  	reqHeaders.Set("Content-Type", "application/json")
  3167  	c.urlParams_.Set("alt", alt)
  3168  	c.urlParams_.Set("prettyPrint", "false")
  3169  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines:run")
  3170  	urls += "?" + c.urlParams_.Encode()
  3171  	req, err := http.NewRequest("POST", urls, body)
  3172  	if err != nil {
  3173  		return nil, err
  3174  	}
  3175  	req.Header = reqHeaders
  3176  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3177  }
  3178  
  3179  // Do executes the "genomics.pipelines.run" call.
  3180  // Exactly one of *Operation or error will be non-nil. Any non-2xx
  3181  // status code is an error. Response headers are in either
  3182  // *Operation.ServerResponse.Header or (if a response was returned at
  3183  // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified
  3184  // to check whether the returned error was because
  3185  // http.StatusNotModified was returned.
  3186  func (c *PipelinesRunCall) Do(opts ...googleapi.CallOption) (*Operation, 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, &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, err
  3204  	}
  3205  	ret := &Operation{
  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  	//   "description": "Runs a pipeline. If `pipelineId` is specified in the request, then run a saved pipeline. If `ephemeralPipeline` is specified, then run that pipeline once without saving a copy. The caller must have READ permission to the project where the pipeline is stored and WRITE permission to the project where the pipeline will be run, as VMs will be created and storage will be used. If a pipeline operation is still running after 6 days, it will be canceled.",
  3218  	//   "flatPath": "v1alpha2/pipelines:run",
  3219  	//   "httpMethod": "POST",
  3220  	//   "id": "genomics.pipelines.run",
  3221  	//   "parameterOrder": [],
  3222  	//   "parameters": {},
  3223  	//   "path": "v1alpha2/pipelines:run",
  3224  	//   "request": {
  3225  	//     "$ref": "RunPipelineRequest"
  3226  	//   },
  3227  	//   "response": {
  3228  	//     "$ref": "Operation"
  3229  	//   },
  3230  	//   "scopes": [
  3231  	//     "https://www.googleapis.com/auth/cloud-platform",
  3232  	//     "https://www.googleapis.com/auth/compute",
  3233  	//     "https://www.googleapis.com/auth/genomics"
  3234  	//   ]
  3235  	// }
  3236  
  3237  }
  3238  
  3239  // method id "genomics.pipelines.setOperationStatus":
  3240  
  3241  type PipelinesSetOperationStatusCall struct {
  3242  	s                         *Service
  3243  	setoperationstatusrequest *SetOperationStatusRequest
  3244  	urlParams_                gensupport.URLParams
  3245  	ctx_                      context.Context
  3246  	header_                   http.Header
  3247  }
  3248  
  3249  // SetOperationStatus: Sets status of a given operation. Any new
  3250  // timestamps (as determined by description) are appended to
  3251  // TimestampEvents. Should only be called by VMs created by the
  3252  // Pipelines Service and not by end users.
  3253  func (r *PipelinesService) SetOperationStatus(setoperationstatusrequest *SetOperationStatusRequest) *PipelinesSetOperationStatusCall {
  3254  	c := &PipelinesSetOperationStatusCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  3255  	c.setoperationstatusrequest = setoperationstatusrequest
  3256  	return c
  3257  }
  3258  
  3259  // Fields allows partial responses to be retrieved. See
  3260  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  3261  // for more information.
  3262  func (c *PipelinesSetOperationStatusCall) Fields(s ...googleapi.Field) *PipelinesSetOperationStatusCall {
  3263  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  3264  	return c
  3265  }
  3266  
  3267  // Context sets the context to be used in this call's Do method. Any
  3268  // pending HTTP request will be aborted if the provided context is
  3269  // canceled.
  3270  func (c *PipelinesSetOperationStatusCall) Context(ctx context.Context) *PipelinesSetOperationStatusCall {
  3271  	c.ctx_ = ctx
  3272  	return c
  3273  }
  3274  
  3275  // Header returns an http.Header that can be modified by the caller to
  3276  // add HTTP headers to the request.
  3277  func (c *PipelinesSetOperationStatusCall) Header() http.Header {
  3278  	if c.header_ == nil {
  3279  		c.header_ = make(http.Header)
  3280  	}
  3281  	return c.header_
  3282  }
  3283  
  3284  func (c *PipelinesSetOperationStatusCall) doRequest(alt string) (*http.Response, error) {
  3285  	reqHeaders := make(http.Header)
  3286  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/20210511")
  3287  	for k, v := range c.header_ {
  3288  		reqHeaders[k] = v
  3289  	}
  3290  	reqHeaders.Set("User-Agent", c.s.userAgent())
  3291  	var body io.Reader = nil
  3292  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.setoperationstatusrequest)
  3293  	if err != nil {
  3294  		return nil, err
  3295  	}
  3296  	reqHeaders.Set("Content-Type", "application/json")
  3297  	c.urlParams_.Set("alt", alt)
  3298  	c.urlParams_.Set("prettyPrint", "false")
  3299  	urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/pipelines:setOperationStatus")
  3300  	urls += "?" + c.urlParams_.Encode()
  3301  	req, err := http.NewRequest("PUT", urls, body)
  3302  	if err != nil {
  3303  		return nil, err
  3304  	}
  3305  	req.Header = reqHeaders
  3306  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  3307  }
  3308  
  3309  // Do executes the "genomics.pipelines.setOperationStatus" call.
  3310  // Exactly one of *Empty or error will be non-nil. Any non-2xx status
  3311  // code is an error. Response headers are in either
  3312  // *Empty.ServerResponse.Header or (if a response was returned at all)
  3313  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  3314  // check whether the returned error was because http.StatusNotModified
  3315  // was returned.
  3316  func (c *PipelinesSetOperationStatusCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  3317  	gensupport.SetOptions(c.urlParams_, opts...)
  3318  	res, err := c.doRequest("json")
  3319  	if res != nil && res.StatusCode == http.StatusNotModified {
  3320  		if res.Body != nil {
  3321  			res.Body.Close()
  3322  		}
  3323  		return nil, &googleapi.Error{
  3324  			Code:   res.StatusCode,
  3325  			Header: res.Header,
  3326  		}
  3327  	}
  3328  	if err != nil {
  3329  		return nil, err
  3330  	}
  3331  	defer googleapi.CloseBody(res)
  3332  	if err := googleapi.CheckResponse(res); err != nil {
  3333  		return nil, err
  3334  	}
  3335  	ret := &Empty{
  3336  		ServerResponse: googleapi.ServerResponse{
  3337  			Header:         res.Header,
  3338  			HTTPStatusCode: res.StatusCode,
  3339  		},
  3340  	}
  3341  	target := &ret
  3342  	if err := gensupport.DecodeResponse(target, res); err != nil {
  3343  		return nil, err
  3344  	}
  3345  	return ret, nil
  3346  	// {
  3347  	//   "description": "Sets status of a given operation. Any new timestamps (as determined by description) are appended to TimestampEvents. Should only be called by VMs created by the Pipelines Service and not by end users.",
  3348  	//   "flatPath": "v1alpha2/pipelines:setOperationStatus",
  3349  	//   "httpMethod": "PUT",
  3350  	//   "id": "genomics.pipelines.setOperationStatus",
  3351  	//   "parameterOrder": [],
  3352  	//   "parameters": {},
  3353  	//   "path": "v1alpha2/pipelines:setOperationStatus",
  3354  	//   "request": {
  3355  	//     "$ref": "SetOperationStatusRequest"
  3356  	//   },
  3357  	//   "response": {
  3358  	//     "$ref": "Empty"
  3359  	//   },
  3360  	//   "scopes": [
  3361  	//     "https://www.googleapis.com/auth/cloud-platform",
  3362  	//     "https://www.googleapis.com/auth/genomics"
  3363  	//   ]
  3364  	// }
  3365  
  3366  }
  3367  

View as plain text