Source file src/google.golang.org/api/clouddebugger/v2/clouddebugger-gen.go

Documentation: google.golang.org/api/clouddebugger/v2

     1  // Copyright 2023 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 clouddebugger provides access to the Cloud Debugger API (Deprecated).
     8  //
     9  // For product documentation, see: https://cloud.google.com/debugger
    10  //
    11  // # Creating a client
    12  //
    13  // Usage example:
    14  //
    15  //	import "google.golang.org/api/clouddebugger/v2"
    16  //	...
    17  //	ctx := context.Background()
    18  //	clouddebuggerService, err := clouddebugger.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  //	clouddebuggerService, err := clouddebugger.NewService(ctx, option.WithScopes(clouddebugger.CloudDebuggerScope))
    29  //
    30  // To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:
    31  //
    32  //	clouddebuggerService, err := clouddebugger.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  //	clouddebuggerService, err := clouddebugger.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 clouddebugger // import "google.golang.org/api/clouddebugger/v2"
    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  	internal "google.golang.org/api/internal"
    58  	gensupport "google.golang.org/api/internal/gensupport"
    59  	option "google.golang.org/api/option"
    60  	internaloption "google.golang.org/api/option/internaloption"
    61  	htransport "google.golang.org/api/transport/http"
    62  )
    63  
    64  // Always reference these packages, just in case the auto-generated code
    65  // below doesn't.
    66  var _ = bytes.NewBuffer
    67  var _ = strconv.Itoa
    68  var _ = fmt.Sprintf
    69  var _ = json.NewDecoder
    70  var _ = io.Copy
    71  var _ = url.Parse
    72  var _ = gensupport.MarshalJSON
    73  var _ = googleapi.Version
    74  var _ = errors.New
    75  var _ = strings.Replace
    76  var _ = context.Canceled
    77  var _ = internaloption.WithDefaultEndpoint
    78  var _ = internal.Version
    79  
    80  const apiId = "clouddebugger:v2"
    81  const apiName = "clouddebugger"
    82  const apiVersion = "v2"
    83  const basePath = "https://clouddebugger.googleapis.com/"
    84  const mtlsBasePath = "https://clouddebugger.mtls.googleapis.com/"
    85  
    86  // OAuth2 scopes used by this API.
    87  const (
    88  	// See, edit, configure, and delete your Google Cloud data and see the
    89  	// email address for your Google Account.
    90  	CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform"
    91  
    92  	// Use Stackdriver Debugger
    93  	CloudDebuggerScope = "https://www.googleapis.com/auth/cloud_debugger"
    94  )
    95  
    96  // NewService creates a new Service.
    97  func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) {
    98  	scopesOption := internaloption.WithDefaultScopes(
    99  		"https://www.googleapis.com/auth/cloud-platform",
   100  		"https://www.googleapis.com/auth/cloud_debugger",
   101  	)
   102  	// NOTE: prepend, so we don't override user-specified scopes.
   103  	opts = append([]option.ClientOption{scopesOption}, opts...)
   104  	opts = append(opts, internaloption.WithDefaultEndpoint(basePath))
   105  	opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath))
   106  	client, endpoint, err := htransport.NewClient(ctx, opts...)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  	s, err := New(client)
   111  	if err != nil {
   112  		return nil, err
   113  	}
   114  	if endpoint != "" {
   115  		s.BasePath = endpoint
   116  	}
   117  	return s, nil
   118  }
   119  
   120  // New creates a new Service. It uses the provided http.Client for requests.
   121  //
   122  // Deprecated: please use NewService instead.
   123  // To provide a custom HTTP client, use option.WithHTTPClient.
   124  // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.
   125  func New(client *http.Client) (*Service, error) {
   126  	if client == nil {
   127  		return nil, errors.New("client is nil")
   128  	}
   129  	s := &Service{client: client, BasePath: basePath}
   130  	s.Controller = NewControllerService(s)
   131  	s.Debugger = NewDebuggerService(s)
   132  	return s, nil
   133  }
   134  
   135  type Service struct {
   136  	client    *http.Client
   137  	BasePath  string // API endpoint base URL
   138  	UserAgent string // optional additional User-Agent fragment
   139  
   140  	Controller *ControllerService
   141  
   142  	Debugger *DebuggerService
   143  }
   144  
   145  func (s *Service) userAgent() string {
   146  	if s.UserAgent == "" {
   147  		return googleapi.UserAgent
   148  	}
   149  	return googleapi.UserAgent + " " + s.UserAgent
   150  }
   151  
   152  func NewControllerService(s *Service) *ControllerService {
   153  	rs := &ControllerService{s: s}
   154  	rs.Debuggees = NewControllerDebuggeesService(s)
   155  	return rs
   156  }
   157  
   158  type ControllerService struct {
   159  	s *Service
   160  
   161  	Debuggees *ControllerDebuggeesService
   162  }
   163  
   164  func NewControllerDebuggeesService(s *Service) *ControllerDebuggeesService {
   165  	rs := &ControllerDebuggeesService{s: s}
   166  	rs.Breakpoints = NewControllerDebuggeesBreakpointsService(s)
   167  	return rs
   168  }
   169  
   170  type ControllerDebuggeesService struct {
   171  	s *Service
   172  
   173  	Breakpoints *ControllerDebuggeesBreakpointsService
   174  }
   175  
   176  func NewControllerDebuggeesBreakpointsService(s *Service) *ControllerDebuggeesBreakpointsService {
   177  	rs := &ControllerDebuggeesBreakpointsService{s: s}
   178  	return rs
   179  }
   180  
   181  type ControllerDebuggeesBreakpointsService struct {
   182  	s *Service
   183  }
   184  
   185  func NewDebuggerService(s *Service) *DebuggerService {
   186  	rs := &DebuggerService{s: s}
   187  	rs.Debuggees = NewDebuggerDebuggeesService(s)
   188  	return rs
   189  }
   190  
   191  type DebuggerService struct {
   192  	s *Service
   193  
   194  	Debuggees *DebuggerDebuggeesService
   195  }
   196  
   197  func NewDebuggerDebuggeesService(s *Service) *DebuggerDebuggeesService {
   198  	rs := &DebuggerDebuggeesService{s: s}
   199  	rs.Breakpoints = NewDebuggerDebuggeesBreakpointsService(s)
   200  	return rs
   201  }
   202  
   203  type DebuggerDebuggeesService struct {
   204  	s *Service
   205  
   206  	Breakpoints *DebuggerDebuggeesBreakpointsService
   207  }
   208  
   209  func NewDebuggerDebuggeesBreakpointsService(s *Service) *DebuggerDebuggeesBreakpointsService {
   210  	rs := &DebuggerDebuggeesBreakpointsService{s: s}
   211  	return rs
   212  }
   213  
   214  type DebuggerDebuggeesBreakpointsService struct {
   215  	s *Service
   216  }
   217  
   218  // AliasContext: An alias to a repo revision.
   219  type AliasContext struct {
   220  	// Kind: The alias kind.
   221  	//
   222  	// Possible values:
   223  	//   "ANY" - Do not use.
   224  	//   "FIXED" - Git tag
   225  	//   "MOVABLE" - Git branch
   226  	//   "OTHER" - OTHER is used to specify non-standard aliases, those not
   227  	// of the kinds above. For example, if a Git repo has a ref named
   228  	// "refs/foo/bar", it is considered to be of kind OTHER.
   229  	Kind string `json:"kind,omitempty"`
   230  
   231  	// Name: The alias name.
   232  	Name string `json:"name,omitempty"`
   233  
   234  	// ForceSendFields is a list of field names (e.g. "Kind") to
   235  	// unconditionally include in API requests. By default, fields with
   236  	// empty or default values are omitted from API requests. However, any
   237  	// non-pointer, non-interface field appearing in ForceSendFields will be
   238  	// sent to the server regardless of whether the field is empty or not.
   239  	// This may be used to include empty fields in Patch requests.
   240  	ForceSendFields []string `json:"-"`
   241  
   242  	// NullFields is a list of field names (e.g. "Kind") to include in API
   243  	// requests with the JSON null value. By default, fields with empty
   244  	// values are omitted from API requests. However, any field with an
   245  	// empty value appearing in NullFields will be sent to the server as
   246  	// null. It is an error if a field in this list has a non-empty value.
   247  	// This may be used to include null fields in Patch requests.
   248  	NullFields []string `json:"-"`
   249  }
   250  
   251  func (s *AliasContext) MarshalJSON() ([]byte, error) {
   252  	type NoMethod AliasContext
   253  	raw := NoMethod(*s)
   254  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   255  }
   256  
   257  // Breakpoint:
   258  // ----------------------------------------------------------------------
   259  // -------- ## Breakpoint (the resource) Represents the breakpoint
   260  // specification, status and results.
   261  type Breakpoint struct {
   262  	// Action: Action that the agent should perform when the code at the
   263  	// breakpoint location is hit.
   264  	//
   265  	// Possible values:
   266  	//   "CAPTURE" - Capture stack frame and variables and update the
   267  	// breakpoint. The data is only captured once. After that the breakpoint
   268  	// is set in a final state.
   269  	//   "LOG" - Log each breakpoint hit. The breakpoint remains active
   270  	// until deleted or expired.
   271  	Action string `json:"action,omitempty"`
   272  
   273  	// CanaryExpireTime: The deadline for the breakpoint to stay in
   274  	// CANARY_ACTIVE state. The value is meaningless when the breakpoint is
   275  	// not in CANARY_ACTIVE state.
   276  	CanaryExpireTime string `json:"canaryExpireTime,omitempty"`
   277  
   278  	// Condition: Condition that triggers the breakpoint. The condition is a
   279  	// compound boolean expression composed using expressions in a
   280  	// programming language at the source location.
   281  	Condition string `json:"condition,omitempty"`
   282  
   283  	// CreateTime: Time this breakpoint was created by the server in seconds
   284  	// resolution.
   285  	CreateTime string `json:"createTime,omitempty"`
   286  
   287  	// EvaluatedExpressions: Values of evaluated expressions at breakpoint
   288  	// time. The evaluated expressions appear in exactly the same order they
   289  	// are listed in the `expressions` field. The `name` field holds the
   290  	// original expression text, the `value` or `members` field holds the
   291  	// result of the evaluated expression. If the expression cannot be
   292  	// evaluated, the `status` inside the `Variable` will indicate an error
   293  	// and contain the error text.
   294  	EvaluatedExpressions []*Variable `json:"evaluatedExpressions,omitempty"`
   295  
   296  	// Expressions: List of read-only expressions to evaluate at the
   297  	// breakpoint location. The expressions are composed using expressions
   298  	// in the programming language at the source location. If the breakpoint
   299  	// action is `LOG`, the evaluated expressions are included in log
   300  	// statements.
   301  	Expressions []string `json:"expressions,omitempty"`
   302  
   303  	// FinalTime: Time this breakpoint was finalized as seen by the server
   304  	// in seconds resolution.
   305  	FinalTime string `json:"finalTime,omitempty"`
   306  
   307  	// Id: Breakpoint identifier, unique in the scope of the debuggee.
   308  	Id string `json:"id,omitempty"`
   309  
   310  	// IsFinalState: When true, indicates that this is a final result and
   311  	// the breakpoint state will not change from here on.
   312  	IsFinalState bool `json:"isFinalState,omitempty"`
   313  
   314  	// Labels: A set of custom breakpoint properties, populated by the
   315  	// agent, to be displayed to the user.
   316  	Labels map[string]string `json:"labels,omitempty"`
   317  
   318  	// Location: Breakpoint source location.
   319  	Location *SourceLocation `json:"location,omitempty"`
   320  
   321  	// LogLevel: Indicates the severity of the log. Only relevant when
   322  	// action is `LOG`.
   323  	//
   324  	// Possible values:
   325  	//   "INFO" - Information log message.
   326  	//   "WARNING" - Warning log message.
   327  	//   "ERROR" - Error log message.
   328  	LogLevel string `json:"logLevel,omitempty"`
   329  
   330  	// LogMessageFormat: Only relevant when action is `LOG`. Defines the
   331  	// message to log when the breakpoint hits. The message may include
   332  	// parameter placeholders `$0`, `$1`, etc. These placeholders are
   333  	// replaced with the evaluated value of the appropriate expression.
   334  	// Expressions not referenced in `log_message_format` are not logged.
   335  	// Example: `Message received, id = $0, count = $1` with `expressions` =
   336  	// `[ message.id, message.count ]`.
   337  	LogMessageFormat string `json:"logMessageFormat,omitempty"`
   338  
   339  	// StackFrames: The stack at breakpoint time, where stack_frames[0]
   340  	// represents the most recently entered function.
   341  	StackFrames []*StackFrame `json:"stackFrames,omitempty"`
   342  
   343  	// State: The current state of the breakpoint.
   344  	//
   345  	// Possible values:
   346  	//   "STATE_UNSPECIFIED" - Breakpoint state UNSPECIFIED.
   347  	//   "STATE_CANARY_PENDING_AGENTS" - Enabling canary but no agents are
   348  	// available.
   349  	//   "STATE_CANARY_ACTIVE" - Enabling canary and successfully assigning
   350  	// canary agents.
   351  	//   "STATE_ROLLING_TO_ALL" - Breakpoint rolling out to all agents.
   352  	//   "STATE_IS_FINAL" - Breakpoint is hit/complete/failed.
   353  	State string `json:"state,omitempty"`
   354  
   355  	// Status: Breakpoint status. The status includes an error flag and a
   356  	// human readable message. This field is usually unset. The message can
   357  	// be either informational or an error message. Regardless, clients
   358  	// should always display the text message back to the user. Error status
   359  	// indicates complete failure of the breakpoint. Example (non-final
   360  	// state): `Still loading symbols...` Examples (final state): * `Invalid
   361  	// line number` referring to location * `Field f not found in class C`
   362  	// referring to condition
   363  	Status *StatusMessage `json:"status,omitempty"`
   364  
   365  	// UserEmail: E-mail address of the user that created this breakpoint
   366  	UserEmail string `json:"userEmail,omitempty"`
   367  
   368  	// VariableTable: The `variable_table` exists to aid with computation,
   369  	// memory and network traffic optimization. It enables storing a
   370  	// variable once and reference it from multiple variables, including
   371  	// variables stored in the `variable_table` itself. For example, the
   372  	// same `this` object, which may appear at many levels of the stack, can
   373  	// have all of its data stored once in this table. The stack frame
   374  	// variables then would hold only a reference to it. The variable
   375  	// `var_table_index` field is an index into this repeated field. The
   376  	// stored objects are nameless and get their name from the referencing
   377  	// variable. The effective variable is a merge of the referencing
   378  	// variable and the referenced variable.
   379  	VariableTable []*Variable `json:"variableTable,omitempty"`
   380  
   381  	// ForceSendFields is a list of field names (e.g. "Action") to
   382  	// unconditionally include in API requests. By default, fields with
   383  	// empty or default values are omitted from API requests. However, any
   384  	// non-pointer, non-interface field appearing in ForceSendFields will be
   385  	// sent to the server regardless of whether the field is empty or not.
   386  	// This may be used to include empty fields in Patch requests.
   387  	ForceSendFields []string `json:"-"`
   388  
   389  	// NullFields is a list of field names (e.g. "Action") to include in API
   390  	// requests with the JSON null value. By default, fields with empty
   391  	// values are omitted from API requests. However, any field with an
   392  	// empty value appearing in NullFields will be sent to the server as
   393  	// null. It is an error if a field in this list has a non-empty value.
   394  	// This may be used to include null fields in Patch requests.
   395  	NullFields []string `json:"-"`
   396  }
   397  
   398  func (s *Breakpoint) MarshalJSON() ([]byte, error) {
   399  	type NoMethod Breakpoint
   400  	raw := NoMethod(*s)
   401  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   402  }
   403  
   404  // CloudRepoSourceContext: A CloudRepoSourceContext denotes a particular
   405  // revision in a cloud repo (a repo hosted by the Google Cloud
   406  // Platform).
   407  type CloudRepoSourceContext struct {
   408  	// AliasContext: An alias, which may be a branch or tag.
   409  	AliasContext *AliasContext `json:"aliasContext,omitempty"`
   410  
   411  	// AliasName: The name of an alias (branch, tag, etc.).
   412  	AliasName string `json:"aliasName,omitempty"`
   413  
   414  	// RepoId: The ID of the repo.
   415  	RepoId *RepoId `json:"repoId,omitempty"`
   416  
   417  	// RevisionId: A revision ID.
   418  	RevisionId string `json:"revisionId,omitempty"`
   419  
   420  	// ForceSendFields is a list of field names (e.g. "AliasContext") to
   421  	// unconditionally include in API requests. By default, fields with
   422  	// empty or default values are omitted from API requests. However, any
   423  	// non-pointer, non-interface field appearing in ForceSendFields will be
   424  	// sent to the server regardless of whether the field is empty or not.
   425  	// This may be used to include empty fields in Patch requests.
   426  	ForceSendFields []string `json:"-"`
   427  
   428  	// NullFields is a list of field names (e.g. "AliasContext") to include
   429  	// in API requests with the JSON null value. By default, fields with
   430  	// empty values are omitted from API requests. However, any field with
   431  	// an empty value appearing in NullFields will be sent to the server as
   432  	// null. It is an error if a field in this list has a non-empty value.
   433  	// This may be used to include null fields in Patch requests.
   434  	NullFields []string `json:"-"`
   435  }
   436  
   437  func (s *CloudRepoSourceContext) MarshalJSON() ([]byte, error) {
   438  	type NoMethod CloudRepoSourceContext
   439  	raw := NoMethod(*s)
   440  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   441  }
   442  
   443  // CloudWorkspaceId: A CloudWorkspaceId is a unique identifier for a
   444  // cloud workspace. A cloud workspace is a place associated with a repo
   445  // where modified files can be stored before they are committed.
   446  type CloudWorkspaceId struct {
   447  	// Name: The unique name of the workspace within the repo. This is the
   448  	// name chosen by the client in the Source API's CreateWorkspace method.
   449  	Name string `json:"name,omitempty"`
   450  
   451  	// RepoId: The ID of the repo containing the workspace.
   452  	RepoId *RepoId `json:"repoId,omitempty"`
   453  
   454  	// ForceSendFields is a list of field names (e.g. "Name") to
   455  	// unconditionally include in API requests. By default, fields with
   456  	// empty or default values are omitted from API requests. However, any
   457  	// non-pointer, non-interface field appearing in ForceSendFields will be
   458  	// sent to the server regardless of whether the field is empty or not.
   459  	// This may be used to include empty fields in Patch requests.
   460  	ForceSendFields []string `json:"-"`
   461  
   462  	// NullFields is a list of field names (e.g. "Name") to include in API
   463  	// requests with the JSON null value. By default, fields with empty
   464  	// values are omitted from API requests. However, any field with an
   465  	// empty value appearing in NullFields will be sent to the server as
   466  	// null. It is an error if a field in this list has a non-empty value.
   467  	// This may be used to include null fields in Patch requests.
   468  	NullFields []string `json:"-"`
   469  }
   470  
   471  func (s *CloudWorkspaceId) MarshalJSON() ([]byte, error) {
   472  	type NoMethod CloudWorkspaceId
   473  	raw := NoMethod(*s)
   474  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   475  }
   476  
   477  // CloudWorkspaceSourceContext: A CloudWorkspaceSourceContext denotes a
   478  // workspace at a particular snapshot.
   479  type CloudWorkspaceSourceContext struct {
   480  	// SnapshotId: The ID of the snapshot. An empty snapshot_id refers to
   481  	// the most recent snapshot.
   482  	SnapshotId string `json:"snapshotId,omitempty"`
   483  
   484  	// WorkspaceId: The ID of the workspace.
   485  	WorkspaceId *CloudWorkspaceId `json:"workspaceId,omitempty"`
   486  
   487  	// ForceSendFields is a list of field names (e.g. "SnapshotId") to
   488  	// unconditionally include in API requests. By default, fields with
   489  	// empty or default values are omitted from API requests. However, any
   490  	// non-pointer, non-interface field appearing in ForceSendFields will be
   491  	// sent to the server regardless of whether the field is empty or not.
   492  	// This may be used to include empty fields in Patch requests.
   493  	ForceSendFields []string `json:"-"`
   494  
   495  	// NullFields is a list of field names (e.g. "SnapshotId") to include in
   496  	// API requests with the JSON null value. By default, fields with empty
   497  	// values are omitted from API requests. However, any field with an
   498  	// empty value appearing in NullFields will be sent to the server as
   499  	// null. It is an error if a field in this list has a non-empty value.
   500  	// This may be used to include null fields in Patch requests.
   501  	NullFields []string `json:"-"`
   502  }
   503  
   504  func (s *CloudWorkspaceSourceContext) MarshalJSON() ([]byte, error) {
   505  	type NoMethod CloudWorkspaceSourceContext
   506  	raw := NoMethod(*s)
   507  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   508  }
   509  
   510  // Debuggee: Represents the debugged application. The application may
   511  // include one or more replicated processes executing the same code.
   512  // Each of these processes is attached with a debugger agent, carrying
   513  // out the debugging commands. Agents attached to the same debuggee
   514  // identify themselves as such by using exactly the same Debuggee
   515  // message value when registering.
   516  type Debuggee struct {
   517  	// AgentVersion: Version ID of the agent. Schema:
   518  	// `domain/language-platform/vmajor.minor` (for example
   519  	// `google.com/java-gcp/v1.1`).
   520  	AgentVersion string `json:"agentVersion,omitempty"`
   521  
   522  	// CanaryMode: Used when setting breakpoint canary for this debuggee.
   523  	//
   524  	// Possible values:
   525  	//   "CANARY_MODE_UNSPECIFIED" - CANARY_MODE_UNSPECIFIED is equivalent
   526  	// to CANARY_MODE_ALWAYS_DISABLED so that if the debuggee is not
   527  	// configured to use the canary feature, the feature will be disabled.
   528  	//   "CANARY_MODE_ALWAYS_ENABLED" - Always enable breakpoint canary
   529  	// regardless of the value of breakpoint's canary option.
   530  	//   "CANARY_MODE_ALWAYS_DISABLED" - Always disable breakpoint canary
   531  	// regardless of the value of breakpoint's canary option.
   532  	//   "CANARY_MODE_DEFAULT_ENABLED" - Depends on the breakpoint's canary
   533  	// option. Enable canary by default if the breakpoint's canary option is
   534  	// not specified.
   535  	//   "CANARY_MODE_DEFAULT_DISABLED" - Depends on the breakpoint's canary
   536  	// option. Disable canary by default if the breakpoint's canary option
   537  	// is not specified.
   538  	CanaryMode string `json:"canaryMode,omitempty"`
   539  
   540  	// Description: Human readable description of the debuggee. Including a
   541  	// human-readable project name, environment name and version information
   542  	// is recommended.
   543  	Description string `json:"description,omitempty"`
   544  
   545  	// ExtSourceContexts: References to the locations and revisions of the
   546  	// source code used in the deployed application.
   547  	ExtSourceContexts []*ExtendedSourceContext `json:"extSourceContexts,omitempty"`
   548  
   549  	// Id: Unique identifier for the debuggee generated by the controller
   550  	// service.
   551  	Id string `json:"id,omitempty"`
   552  
   553  	// IsDisabled: If set to `true`, indicates that the agent should disable
   554  	// itself and detach from the debuggee.
   555  	IsDisabled bool `json:"isDisabled,omitempty"`
   556  
   557  	// IsInactive: If set to `true`, indicates that Controller service does
   558  	// not detect any activity from the debuggee agents and the application
   559  	// is possibly stopped.
   560  	IsInactive bool `json:"isInactive,omitempty"`
   561  
   562  	// Labels: A set of custom debuggee properties, populated by the agent,
   563  	// to be displayed to the user.
   564  	Labels map[string]string `json:"labels,omitempty"`
   565  
   566  	// Project: Project the debuggee is associated with. Use project number
   567  	// or id when registering a Google Cloud Platform project.
   568  	Project string `json:"project,omitempty"`
   569  
   570  	// SourceContexts: References to the locations and revisions of the
   571  	// source code used in the deployed application.
   572  	SourceContexts []*SourceContext `json:"sourceContexts,omitempty"`
   573  
   574  	// Status: Human readable message to be displayed to the user about this
   575  	// debuggee. Absence of this field indicates no status. The message can
   576  	// be either informational or an error status.
   577  	Status *StatusMessage `json:"status,omitempty"`
   578  
   579  	// Uniquifier: Uniquifier to further distinguish the application. It is
   580  	// possible that different applications might have identical values in
   581  	// the debuggee message, thus, incorrectly identified as a single
   582  	// application by the Controller service. This field adds salt to
   583  	// further distinguish the application. Agents should consider seeding
   584  	// this field with value that identifies the code, binary, configuration
   585  	// and environment.
   586  	Uniquifier string `json:"uniquifier,omitempty"`
   587  
   588  	// ForceSendFields is a list of field names (e.g. "AgentVersion") to
   589  	// unconditionally include in API requests. By default, fields with
   590  	// empty or default values are omitted from API requests. However, any
   591  	// non-pointer, non-interface field appearing in ForceSendFields will be
   592  	// sent to the server regardless of whether the field is empty or not.
   593  	// This may be used to include empty fields in Patch requests.
   594  	ForceSendFields []string `json:"-"`
   595  
   596  	// NullFields is a list of field names (e.g. "AgentVersion") to include
   597  	// in API requests with the JSON null value. By default, fields with
   598  	// empty values are omitted from API requests. However, any field with
   599  	// an empty value appearing in NullFields will be sent to the server as
   600  	// null. It is an error if a field in this list has a non-empty value.
   601  	// This may be used to include null fields in Patch requests.
   602  	NullFields []string `json:"-"`
   603  }
   604  
   605  func (s *Debuggee) MarshalJSON() ([]byte, error) {
   606  	type NoMethod Debuggee
   607  	raw := NoMethod(*s)
   608  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   609  }
   610  
   611  // Empty: A generic empty message that you can re-use to avoid defining
   612  // duplicated empty messages in your APIs. A typical example is to use
   613  // it as the request or the response type of an API method. For
   614  // instance: service Foo { rpc Bar(google.protobuf.Empty) returns
   615  // (google.protobuf.Empty); }
   616  type Empty struct {
   617  	// ServerResponse contains the HTTP response code and headers from the
   618  	// server.
   619  	googleapi.ServerResponse `json:"-"`
   620  }
   621  
   622  // ExtendedSourceContext: An ExtendedSourceContext is a SourceContext
   623  // combined with additional details describing the context.
   624  type ExtendedSourceContext struct {
   625  	// Context: Any source context.
   626  	Context *SourceContext `json:"context,omitempty"`
   627  
   628  	// Labels: Labels with user defined metadata.
   629  	Labels map[string]string `json:"labels,omitempty"`
   630  
   631  	// ForceSendFields is a list of field names (e.g. "Context") to
   632  	// unconditionally include in API requests. By default, fields with
   633  	// empty or default values are omitted from API requests. However, any
   634  	// non-pointer, non-interface field appearing in ForceSendFields will be
   635  	// sent to the server regardless of whether the field is empty or not.
   636  	// This may be used to include empty fields in Patch requests.
   637  	ForceSendFields []string `json:"-"`
   638  
   639  	// NullFields is a list of field names (e.g. "Context") to include in
   640  	// API requests with the JSON null value. By default, fields with empty
   641  	// values are omitted from API requests. However, any field with an
   642  	// empty value appearing in NullFields will be sent to the server as
   643  	// null. It is an error if a field in this list has a non-empty value.
   644  	// This may be used to include null fields in Patch requests.
   645  	NullFields []string `json:"-"`
   646  }
   647  
   648  func (s *ExtendedSourceContext) MarshalJSON() ([]byte, error) {
   649  	type NoMethod ExtendedSourceContext
   650  	raw := NoMethod(*s)
   651  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   652  }
   653  
   654  // FormatMessage: Represents a message with parameters.
   655  type FormatMessage struct {
   656  	// Format: Format template for the message. The `format` uses
   657  	// placeholders `$0`, `$1`, etc. to reference parameters. `$$` can be
   658  	// used to denote the `$` character. Examples: * `Failed to load '$0'
   659  	// which helps debug $1 the first time it is loaded. Again, $0 is very
   660  	// important.` * `Please pay $$10 to use $0 instead of $1.`
   661  	Format string `json:"format,omitempty"`
   662  
   663  	// Parameters: Optional parameters to be embedded into the message.
   664  	Parameters []string `json:"parameters,omitempty"`
   665  
   666  	// ForceSendFields is a list of field names (e.g. "Format") to
   667  	// unconditionally include in API requests. By default, fields with
   668  	// empty or default values are omitted from API requests. However, any
   669  	// non-pointer, non-interface field appearing in ForceSendFields will be
   670  	// sent to the server regardless of whether the field is empty or not.
   671  	// This may be used to include empty fields in Patch requests.
   672  	ForceSendFields []string `json:"-"`
   673  
   674  	// NullFields is a list of field names (e.g. "Format") to include in API
   675  	// requests with the JSON null value. By default, fields with empty
   676  	// values are omitted from API requests. However, any field with an
   677  	// empty value appearing in NullFields will be sent to the server as
   678  	// null. It is an error if a field in this list has a non-empty value.
   679  	// This may be used to include null fields in Patch requests.
   680  	NullFields []string `json:"-"`
   681  }
   682  
   683  func (s *FormatMessage) MarshalJSON() ([]byte, error) {
   684  	type NoMethod FormatMessage
   685  	raw := NoMethod(*s)
   686  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   687  }
   688  
   689  // GerritSourceContext: A SourceContext referring to a Gerrit project.
   690  type GerritSourceContext struct {
   691  	// AliasContext: An alias, which may be a branch or tag.
   692  	AliasContext *AliasContext `json:"aliasContext,omitempty"`
   693  
   694  	// AliasName: The name of an alias (branch, tag, etc.).
   695  	AliasName string `json:"aliasName,omitempty"`
   696  
   697  	// GerritProject: The full project name within the host. Projects may be
   698  	// nested, so "project/subproject" is a valid project name. The "repo
   699  	// name" is hostURI/project.
   700  	GerritProject string `json:"gerritProject,omitempty"`
   701  
   702  	// HostUri: The URI of a running Gerrit instance.
   703  	HostUri string `json:"hostUri,omitempty"`
   704  
   705  	// RevisionId: A revision (commit) ID.
   706  	RevisionId string `json:"revisionId,omitempty"`
   707  
   708  	// ForceSendFields is a list of field names (e.g. "AliasContext") to
   709  	// unconditionally include in API requests. By default, fields with
   710  	// empty or default values are omitted from API requests. However, any
   711  	// non-pointer, non-interface field appearing in ForceSendFields will be
   712  	// sent to the server regardless of whether the field is empty or not.
   713  	// This may be used to include empty fields in Patch requests.
   714  	ForceSendFields []string `json:"-"`
   715  
   716  	// NullFields is a list of field names (e.g. "AliasContext") 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 *GerritSourceContext) MarshalJSON() ([]byte, error) {
   726  	type NoMethod GerritSourceContext
   727  	raw := NoMethod(*s)
   728  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   729  }
   730  
   731  // GetBreakpointResponse: Response for getting breakpoint information.
   732  type GetBreakpointResponse struct {
   733  	// Breakpoint: Complete breakpoint state. The fields `id` and `location`
   734  	// are guaranteed to be set.
   735  	Breakpoint *Breakpoint `json:"breakpoint,omitempty"`
   736  
   737  	// ServerResponse contains the HTTP response code and headers from the
   738  	// server.
   739  	googleapi.ServerResponse `json:"-"`
   740  
   741  	// ForceSendFields is a list of field names (e.g. "Breakpoint") to
   742  	// unconditionally include in API requests. By default, fields with
   743  	// empty or default values are omitted from API requests. However, any
   744  	// non-pointer, non-interface field appearing in ForceSendFields will be
   745  	// sent to the server regardless of whether the field is empty or not.
   746  	// This may be used to include empty fields in Patch requests.
   747  	ForceSendFields []string `json:"-"`
   748  
   749  	// NullFields is a list of field names (e.g. "Breakpoint") to include in
   750  	// API requests with the JSON null value. By default, fields with empty
   751  	// values are omitted from API requests. However, any field with an
   752  	// empty value appearing in NullFields will be sent to the server as
   753  	// null. It is an error if a field in this list has a non-empty value.
   754  	// This may be used to include null fields in Patch requests.
   755  	NullFields []string `json:"-"`
   756  }
   757  
   758  func (s *GetBreakpointResponse) MarshalJSON() ([]byte, error) {
   759  	type NoMethod GetBreakpointResponse
   760  	raw := NoMethod(*s)
   761  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   762  }
   763  
   764  // GitSourceContext: A GitSourceContext denotes a particular revision in
   765  // a third party Git repository (e.g. GitHub).
   766  type GitSourceContext struct {
   767  	// RevisionId: Git commit hash. required.
   768  	RevisionId string `json:"revisionId,omitempty"`
   769  
   770  	// Url: Git repository URL.
   771  	Url string `json:"url,omitempty"`
   772  
   773  	// ForceSendFields is a list of field names (e.g. "RevisionId") to
   774  	// unconditionally include in API requests. By default, fields with
   775  	// empty or default values are omitted from API requests. However, any
   776  	// non-pointer, non-interface field appearing in ForceSendFields will be
   777  	// sent to the server regardless of whether the field is empty or not.
   778  	// This may be used to include empty fields in Patch requests.
   779  	ForceSendFields []string `json:"-"`
   780  
   781  	// NullFields is a list of field names (e.g. "RevisionId") to include in
   782  	// API requests with the JSON null value. By default, fields with empty
   783  	// values are omitted from API requests. However, any field with an
   784  	// empty value appearing in NullFields will be sent to the server as
   785  	// null. It is an error if a field in this list has a non-empty value.
   786  	// This may be used to include null fields in Patch requests.
   787  	NullFields []string `json:"-"`
   788  }
   789  
   790  func (s *GitSourceContext) MarshalJSON() ([]byte, error) {
   791  	type NoMethod GitSourceContext
   792  	raw := NoMethod(*s)
   793  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   794  }
   795  
   796  // ListActiveBreakpointsResponse: Response for listing active
   797  // breakpoints.
   798  type ListActiveBreakpointsResponse struct {
   799  	// Breakpoints: List of all active breakpoints. The fields `id` and
   800  	// `location` are guaranteed to be set on each breakpoint.
   801  	Breakpoints []*Breakpoint `json:"breakpoints,omitempty"`
   802  
   803  	// NextWaitToken: A token that can be used in the next method call to
   804  	// block until the list of breakpoints changes.
   805  	NextWaitToken string `json:"nextWaitToken,omitempty"`
   806  
   807  	// WaitExpired: If set to `true`, indicates that there is no change to
   808  	// the list of active breakpoints and the server-selected timeout has
   809  	// expired. The `breakpoints` field would be empty and should be
   810  	// ignored.
   811  	WaitExpired bool `json:"waitExpired,omitempty"`
   812  
   813  	// ServerResponse contains the HTTP response code and headers from the
   814  	// server.
   815  	googleapi.ServerResponse `json:"-"`
   816  
   817  	// ForceSendFields is a list of field names (e.g. "Breakpoints") to
   818  	// unconditionally include in API requests. By default, fields with
   819  	// empty or default values are omitted from API requests. However, any
   820  	// non-pointer, non-interface field appearing in ForceSendFields will be
   821  	// sent to the server regardless of whether the field is empty or not.
   822  	// This may be used to include empty fields in Patch requests.
   823  	ForceSendFields []string `json:"-"`
   824  
   825  	// NullFields is a list of field names (e.g. "Breakpoints") to include
   826  	// in API requests with the JSON null value. By default, fields with
   827  	// empty values are omitted from API requests. However, any field with
   828  	// an empty value appearing in NullFields will be sent to the server as
   829  	// null. It is an error if a field in this list has a non-empty value.
   830  	// This may be used to include null fields in Patch requests.
   831  	NullFields []string `json:"-"`
   832  }
   833  
   834  func (s *ListActiveBreakpointsResponse) MarshalJSON() ([]byte, error) {
   835  	type NoMethod ListActiveBreakpointsResponse
   836  	raw := NoMethod(*s)
   837  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   838  }
   839  
   840  // ListBreakpointsResponse: Response for listing breakpoints.
   841  type ListBreakpointsResponse struct {
   842  	// Breakpoints: List of breakpoints matching the request. The fields
   843  	// `id` and `location` are guaranteed to be set on each breakpoint. The
   844  	// fields: `stack_frames`, `evaluated_expressions` and `variable_table`
   845  	// are cleared on each breakpoint regardless of its status.
   846  	Breakpoints []*Breakpoint `json:"breakpoints,omitempty"`
   847  
   848  	// NextWaitToken: A wait token that can be used in the next call to
   849  	// `list` (REST) or `ListBreakpoints` (RPC) to block until the list of
   850  	// breakpoints has changes.
   851  	NextWaitToken string `json:"nextWaitToken,omitempty"`
   852  
   853  	// ServerResponse contains the HTTP response code and headers from the
   854  	// server.
   855  	googleapi.ServerResponse `json:"-"`
   856  
   857  	// ForceSendFields is a list of field names (e.g. "Breakpoints") to
   858  	// unconditionally include in API requests. By default, fields with
   859  	// empty or default values are omitted from API requests. However, any
   860  	// non-pointer, non-interface field appearing in ForceSendFields will be
   861  	// sent to the server regardless of whether the field is empty or not.
   862  	// This may be used to include empty fields in Patch requests.
   863  	ForceSendFields []string `json:"-"`
   864  
   865  	// NullFields is a list of field names (e.g. "Breakpoints") to include
   866  	// in API requests with the JSON null value. By default, fields with
   867  	// empty values are omitted from API requests. However, any field with
   868  	// an empty value appearing in NullFields will be sent to the server as
   869  	// null. It is an error if a field in this list has a non-empty value.
   870  	// This may be used to include null fields in Patch requests.
   871  	NullFields []string `json:"-"`
   872  }
   873  
   874  func (s *ListBreakpointsResponse) MarshalJSON() ([]byte, error) {
   875  	type NoMethod ListBreakpointsResponse
   876  	raw := NoMethod(*s)
   877  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   878  }
   879  
   880  // ListDebuggeesResponse: Response for listing debuggees.
   881  type ListDebuggeesResponse struct {
   882  	// Debuggees: List of debuggees accessible to the calling user. The
   883  	// fields `debuggee.id` and `description` are guaranteed to be set. The
   884  	// `description` field is a human readable field provided by agents and
   885  	// can be displayed to users.
   886  	Debuggees []*Debuggee `json:"debuggees,omitempty"`
   887  
   888  	// ServerResponse contains the HTTP response code and headers from the
   889  	// server.
   890  	googleapi.ServerResponse `json:"-"`
   891  
   892  	// ForceSendFields is a list of field names (e.g. "Debuggees") to
   893  	// unconditionally include in API requests. By default, fields with
   894  	// empty or default values are omitted from API requests. However, any
   895  	// non-pointer, non-interface field appearing in ForceSendFields will be
   896  	// sent to the server regardless of whether the field is empty or not.
   897  	// This may be used to include empty fields in Patch requests.
   898  	ForceSendFields []string `json:"-"`
   899  
   900  	// NullFields is a list of field names (e.g. "Debuggees") to include in
   901  	// API requests with the JSON null value. By default, fields with empty
   902  	// values are omitted from API requests. However, any field with an
   903  	// empty value appearing in NullFields will be sent to the server as
   904  	// null. It is an error if a field in this list has a non-empty value.
   905  	// This may be used to include null fields in Patch requests.
   906  	NullFields []string `json:"-"`
   907  }
   908  
   909  func (s *ListDebuggeesResponse) MarshalJSON() ([]byte, error) {
   910  	type NoMethod ListDebuggeesResponse
   911  	raw := NoMethod(*s)
   912  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   913  }
   914  
   915  // ProjectRepoId: Selects a repo using a Google Cloud Platform project
   916  // ID (e.g. winged-cargo-31) and a repo name within that project.
   917  type ProjectRepoId struct {
   918  	// ProjectId: The ID of the project.
   919  	ProjectId string `json:"projectId,omitempty"`
   920  
   921  	// RepoName: The name of the repo. Leave empty for the default repo.
   922  	RepoName string `json:"repoName,omitempty"`
   923  
   924  	// ForceSendFields is a list of field names (e.g. "ProjectId") to
   925  	// unconditionally include in API requests. By default, fields with
   926  	// empty or default values are omitted from API requests. However, any
   927  	// non-pointer, non-interface field appearing in ForceSendFields will be
   928  	// sent to the server regardless of whether the field is empty or not.
   929  	// This may be used to include empty fields in Patch requests.
   930  	ForceSendFields []string `json:"-"`
   931  
   932  	// NullFields is a list of field names (e.g. "ProjectId") to include in
   933  	// API requests with the JSON null value. By default, fields with empty
   934  	// values are omitted from API requests. However, any field with an
   935  	// empty value appearing in NullFields will be sent to the server as
   936  	// null. It is an error if a field in this list has a non-empty value.
   937  	// This may be used to include null fields in Patch requests.
   938  	NullFields []string `json:"-"`
   939  }
   940  
   941  func (s *ProjectRepoId) MarshalJSON() ([]byte, error) {
   942  	type NoMethod ProjectRepoId
   943  	raw := NoMethod(*s)
   944  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   945  }
   946  
   947  // RegisterDebuggeeRequest: Request to register a debuggee.
   948  type RegisterDebuggeeRequest struct {
   949  	// Debuggee: Required. Debuggee information to register. The fields
   950  	// `project`, `uniquifier`, `description` and `agent_version` of the
   951  	// debuggee must be set.
   952  	Debuggee *Debuggee `json:"debuggee,omitempty"`
   953  
   954  	// ForceSendFields is a list of field names (e.g. "Debuggee") to
   955  	// unconditionally include in API requests. By default, fields with
   956  	// empty or default values are omitted from API requests. However, any
   957  	// non-pointer, non-interface field appearing in ForceSendFields will be
   958  	// sent to the server regardless of whether the field is empty or not.
   959  	// This may be used to include empty fields in Patch requests.
   960  	ForceSendFields []string `json:"-"`
   961  
   962  	// NullFields is a list of field names (e.g. "Debuggee") to include in
   963  	// API requests with the JSON null value. By default, fields with empty
   964  	// values are omitted from API requests. However, any field with an
   965  	// empty value appearing in NullFields will be sent to the server as
   966  	// null. It is an error if a field in this list has a non-empty value.
   967  	// This may be used to include null fields in Patch requests.
   968  	NullFields []string `json:"-"`
   969  }
   970  
   971  func (s *RegisterDebuggeeRequest) MarshalJSON() ([]byte, error) {
   972  	type NoMethod RegisterDebuggeeRequest
   973  	raw := NoMethod(*s)
   974  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
   975  }
   976  
   977  // RegisterDebuggeeResponse: Response for registering a debuggee.
   978  type RegisterDebuggeeResponse struct {
   979  	// AgentId: A unique ID generated for the agent. Each RegisterDebuggee
   980  	// request will generate a new agent ID.
   981  	AgentId string `json:"agentId,omitempty"`
   982  
   983  	// Debuggee: Debuggee resource. The field `id` is guaranteed to be set
   984  	// (in addition to the echoed fields). If the field `is_disabled` is set
   985  	// to `true`, the agent should disable itself by removing all
   986  	// breakpoints and detaching from the application. It should however
   987  	// continue to poll `RegisterDebuggee` until reenabled.
   988  	Debuggee *Debuggee `json:"debuggee,omitempty"`
   989  
   990  	// ServerResponse contains the HTTP response code and headers from the
   991  	// server.
   992  	googleapi.ServerResponse `json:"-"`
   993  
   994  	// ForceSendFields is a list of field names (e.g. "AgentId") to
   995  	// unconditionally include in API requests. By default, fields with
   996  	// empty or default values are omitted from API requests. However, any
   997  	// non-pointer, non-interface field appearing in ForceSendFields will be
   998  	// sent to the server regardless of whether the field is empty or not.
   999  	// This may be used to include empty fields in Patch requests.
  1000  	ForceSendFields []string `json:"-"`
  1001  
  1002  	// NullFields is a list of field names (e.g. "AgentId") to include in
  1003  	// API requests with the JSON null value. By default, fields with empty
  1004  	// values are omitted from API requests. However, any field with an
  1005  	// empty value appearing in NullFields will be sent to the server as
  1006  	// null. It is an error if a field in this list has a non-empty value.
  1007  	// This may be used to include null fields in Patch requests.
  1008  	NullFields []string `json:"-"`
  1009  }
  1010  
  1011  func (s *RegisterDebuggeeResponse) MarshalJSON() ([]byte, error) {
  1012  	type NoMethod RegisterDebuggeeResponse
  1013  	raw := NoMethod(*s)
  1014  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1015  }
  1016  
  1017  // RepoId: A unique identifier for a cloud repo.
  1018  type RepoId struct {
  1019  	// ProjectRepoId: A combination of a project ID and a repo name.
  1020  	ProjectRepoId *ProjectRepoId `json:"projectRepoId,omitempty"`
  1021  
  1022  	// Uid: A server-assigned, globally unique identifier.
  1023  	Uid string `json:"uid,omitempty"`
  1024  
  1025  	// ForceSendFields is a list of field names (e.g. "ProjectRepoId") to
  1026  	// unconditionally include in API requests. By default, fields with
  1027  	// empty or default values are omitted from API requests. However, any
  1028  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1029  	// sent to the server regardless of whether the field is empty or not.
  1030  	// This may be used to include empty fields in Patch requests.
  1031  	ForceSendFields []string `json:"-"`
  1032  
  1033  	// NullFields is a list of field names (e.g. "ProjectRepoId") to include
  1034  	// in API requests with the JSON null value. By default, fields with
  1035  	// empty values are omitted from API requests. However, any field with
  1036  	// an empty value appearing in NullFields will be sent to the server as
  1037  	// null. It is an error if a field in this list has a non-empty value.
  1038  	// This may be used to include null fields in Patch requests.
  1039  	NullFields []string `json:"-"`
  1040  }
  1041  
  1042  func (s *RepoId) MarshalJSON() ([]byte, error) {
  1043  	type NoMethod RepoId
  1044  	raw := NoMethod(*s)
  1045  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1046  }
  1047  
  1048  // SetBreakpointResponse: Response for setting a breakpoint.
  1049  type SetBreakpointResponse struct {
  1050  	// Breakpoint: Breakpoint resource. The field `id` is guaranteed to be
  1051  	// set (in addition to the echoed fields).
  1052  	Breakpoint *Breakpoint `json:"breakpoint,omitempty"`
  1053  
  1054  	// ServerResponse contains the HTTP response code and headers from the
  1055  	// server.
  1056  	googleapi.ServerResponse `json:"-"`
  1057  
  1058  	// ForceSendFields is a list of field names (e.g. "Breakpoint") to
  1059  	// unconditionally include in API requests. By default, fields with
  1060  	// empty or default values are omitted from API requests. However, any
  1061  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1062  	// sent to the server regardless of whether the field is empty or not.
  1063  	// This may be used to include empty fields in Patch requests.
  1064  	ForceSendFields []string `json:"-"`
  1065  
  1066  	// NullFields is a list of field names (e.g. "Breakpoint") to include in
  1067  	// API requests with the JSON null value. By default, fields with empty
  1068  	// values are omitted from API requests. However, any field with an
  1069  	// empty value appearing in NullFields will be sent to the server as
  1070  	// null. It is an error if a field in this list has a non-empty value.
  1071  	// This may be used to include null fields in Patch requests.
  1072  	NullFields []string `json:"-"`
  1073  }
  1074  
  1075  func (s *SetBreakpointResponse) MarshalJSON() ([]byte, error) {
  1076  	type NoMethod SetBreakpointResponse
  1077  	raw := NoMethod(*s)
  1078  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1079  }
  1080  
  1081  // SourceContext: A SourceContext is a reference to a tree of files. A
  1082  // SourceContext together with a path point to a unique revision of a
  1083  // single file or directory.
  1084  type SourceContext struct {
  1085  	// CloudRepo: A SourceContext referring to a revision in a cloud repo.
  1086  	CloudRepo *CloudRepoSourceContext `json:"cloudRepo,omitempty"`
  1087  
  1088  	// CloudWorkspace: A SourceContext referring to a snapshot in a cloud
  1089  	// workspace.
  1090  	CloudWorkspace *CloudWorkspaceSourceContext `json:"cloudWorkspace,omitempty"`
  1091  
  1092  	// Gerrit: A SourceContext referring to a Gerrit project.
  1093  	Gerrit *GerritSourceContext `json:"gerrit,omitempty"`
  1094  
  1095  	// Git: A SourceContext referring to any third party Git repo (e.g.
  1096  	// GitHub).
  1097  	Git *GitSourceContext `json:"git,omitempty"`
  1098  
  1099  	// ForceSendFields is a list of field names (e.g. "CloudRepo") to
  1100  	// unconditionally include in API requests. By default, fields with
  1101  	// empty or default values are omitted from API requests. However, any
  1102  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1103  	// sent to the server regardless of whether the field is empty or not.
  1104  	// This may be used to include empty fields in Patch requests.
  1105  	ForceSendFields []string `json:"-"`
  1106  
  1107  	// NullFields is a list of field names (e.g. "CloudRepo") to include in
  1108  	// API requests with the JSON null value. By default, fields with empty
  1109  	// values are omitted from API requests. However, any field with an
  1110  	// empty value appearing in NullFields will be sent to the server as
  1111  	// null. It is an error if a field in this list has a non-empty value.
  1112  	// This may be used to include null fields in Patch requests.
  1113  	NullFields []string `json:"-"`
  1114  }
  1115  
  1116  func (s *SourceContext) MarshalJSON() ([]byte, error) {
  1117  	type NoMethod SourceContext
  1118  	raw := NoMethod(*s)
  1119  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1120  }
  1121  
  1122  // SourceLocation: Represents a location in the source code.
  1123  type SourceLocation struct {
  1124  	// Column: Column within a line. The first column in a line as the value
  1125  	// `1`. Agents that do not support setting breakpoints on specific
  1126  	// columns ignore this field.
  1127  	Column int64 `json:"column,omitempty"`
  1128  
  1129  	// Line: Line inside the file. The first line in the file has the value
  1130  	// `1`.
  1131  	Line int64 `json:"line,omitempty"`
  1132  
  1133  	// Path: Path to the source file within the source context of the target
  1134  	// binary.
  1135  	Path string `json:"path,omitempty"`
  1136  
  1137  	// ForceSendFields is a list of field names (e.g. "Column") to
  1138  	// unconditionally include in API requests. By default, fields with
  1139  	// empty or default values are omitted from API requests. However, any
  1140  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1141  	// sent to the server regardless of whether the field is empty or not.
  1142  	// This may be used to include empty fields in Patch requests.
  1143  	ForceSendFields []string `json:"-"`
  1144  
  1145  	// NullFields is a list of field names (e.g. "Column") to include in API
  1146  	// requests with the JSON null value. By default, fields with empty
  1147  	// values are omitted from API requests. However, any field with an
  1148  	// empty value appearing in NullFields will be sent to the server as
  1149  	// null. It is an error if a field in this list has a non-empty value.
  1150  	// This may be used to include null fields in Patch requests.
  1151  	NullFields []string `json:"-"`
  1152  }
  1153  
  1154  func (s *SourceLocation) MarshalJSON() ([]byte, error) {
  1155  	type NoMethod SourceLocation
  1156  	raw := NoMethod(*s)
  1157  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1158  }
  1159  
  1160  // StackFrame: Represents a stack frame context.
  1161  type StackFrame struct {
  1162  	// Arguments: Set of arguments passed to this function. Note that this
  1163  	// might not be populated for all stack frames.
  1164  	Arguments []*Variable `json:"arguments,omitempty"`
  1165  
  1166  	// Function: Demangled function name at the call site.
  1167  	Function string `json:"function,omitempty"`
  1168  
  1169  	// Locals: Set of local variables at the stack frame location. Note that
  1170  	// this might not be populated for all stack frames.
  1171  	Locals []*Variable `json:"locals,omitempty"`
  1172  
  1173  	// Location: Source location of the call site.
  1174  	Location *SourceLocation `json:"location,omitempty"`
  1175  
  1176  	// ForceSendFields is a list of field names (e.g. "Arguments") to
  1177  	// unconditionally include in API requests. By default, fields with
  1178  	// empty or default values are omitted from API requests. However, any
  1179  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1180  	// sent to the server regardless of whether the field is empty or not.
  1181  	// This may be used to include empty fields in Patch requests.
  1182  	ForceSendFields []string `json:"-"`
  1183  
  1184  	// NullFields is a list of field names (e.g. "Arguments") to include in
  1185  	// API requests with the JSON null value. By default, fields with empty
  1186  	// values are omitted from API requests. However, any field with an
  1187  	// empty value appearing in NullFields will be sent to the server as
  1188  	// null. It is an error if a field in this list has a non-empty value.
  1189  	// This may be used to include null fields in Patch requests.
  1190  	NullFields []string `json:"-"`
  1191  }
  1192  
  1193  func (s *StackFrame) MarshalJSON() ([]byte, error) {
  1194  	type NoMethod StackFrame
  1195  	raw := NoMethod(*s)
  1196  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1197  }
  1198  
  1199  // StatusMessage: Represents a contextual status message. The message
  1200  // can indicate an error or informational status, and refer to specific
  1201  // parts of the containing object. For example, the `Breakpoint.status`
  1202  // field can indicate an error referring to the
  1203  // `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
  1204  type StatusMessage struct {
  1205  	// Description: Status message text.
  1206  	Description *FormatMessage `json:"description,omitempty"`
  1207  
  1208  	// IsError: Distinguishes errors from informational messages.
  1209  	IsError bool `json:"isError,omitempty"`
  1210  
  1211  	// RefersTo: Reference to which the message applies.
  1212  	//
  1213  	// Possible values:
  1214  	//   "UNSPECIFIED" - Status doesn't refer to any particular input.
  1215  	//   "BREAKPOINT_SOURCE_LOCATION" - Status applies to the breakpoint and
  1216  	// is related to its location.
  1217  	//   "BREAKPOINT_CONDITION" - Status applies to the breakpoint and is
  1218  	// related to its condition.
  1219  	//   "BREAKPOINT_EXPRESSION" - Status applies to the breakpoint and is
  1220  	// related to its expressions.
  1221  	//   "BREAKPOINT_AGE" - Status applies to the breakpoint and is related
  1222  	// to its age.
  1223  	//   "BREAKPOINT_CANARY_FAILED" - Status applies to the breakpoint when
  1224  	// the breakpoint failed to exit the canary state.
  1225  	//   "VARIABLE_NAME" - Status applies to the entire variable.
  1226  	//   "VARIABLE_VALUE" - Status applies to variable value (variable name
  1227  	// is valid).
  1228  	RefersTo string `json:"refersTo,omitempty"`
  1229  
  1230  	// ForceSendFields is a list of field names (e.g. "Description") to
  1231  	// unconditionally include in API requests. By default, fields with
  1232  	// empty or default values are omitted from API requests. However, any
  1233  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1234  	// sent to the server regardless of whether the field is empty or not.
  1235  	// This may be used to include empty fields in Patch requests.
  1236  	ForceSendFields []string `json:"-"`
  1237  
  1238  	// NullFields is a list of field names (e.g. "Description") to include
  1239  	// in API requests with the JSON null value. By default, fields with
  1240  	// empty values are omitted from API requests. However, any field with
  1241  	// an empty value appearing in NullFields will be sent to the server as
  1242  	// null. It is an error if a field in this list has a non-empty value.
  1243  	// This may be used to include null fields in Patch requests.
  1244  	NullFields []string `json:"-"`
  1245  }
  1246  
  1247  func (s *StatusMessage) MarshalJSON() ([]byte, error) {
  1248  	type NoMethod StatusMessage
  1249  	raw := NoMethod(*s)
  1250  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1251  }
  1252  
  1253  // UpdateActiveBreakpointRequest: Request to update an active
  1254  // breakpoint.
  1255  type UpdateActiveBreakpointRequest struct {
  1256  	// Breakpoint: Required. Updated breakpoint information. The field `id`
  1257  	// must be set. The agent must echo all Breakpoint specification fields
  1258  	// in the update.
  1259  	Breakpoint *Breakpoint `json:"breakpoint,omitempty"`
  1260  
  1261  	// ForceSendFields is a list of field names (e.g. "Breakpoint") to
  1262  	// unconditionally include in API requests. By default, fields with
  1263  	// empty or default values are omitted from API requests. However, any
  1264  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1265  	// sent to the server regardless of whether the field is empty or not.
  1266  	// This may be used to include empty fields in Patch requests.
  1267  	ForceSendFields []string `json:"-"`
  1268  
  1269  	// NullFields is a list of field names (e.g. "Breakpoint") to include in
  1270  	// API requests with the JSON null value. By default, fields with empty
  1271  	// values are omitted from API requests. However, any field with an
  1272  	// empty value appearing in NullFields will be sent to the server as
  1273  	// null. It is an error if a field in this list has a non-empty value.
  1274  	// This may be used to include null fields in Patch requests.
  1275  	NullFields []string `json:"-"`
  1276  }
  1277  
  1278  func (s *UpdateActiveBreakpointRequest) MarshalJSON() ([]byte, error) {
  1279  	type NoMethod UpdateActiveBreakpointRequest
  1280  	raw := NoMethod(*s)
  1281  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1282  }
  1283  
  1284  // UpdateActiveBreakpointResponse: Response for updating an active
  1285  // breakpoint. The message is defined to allow future extensions.
  1286  type UpdateActiveBreakpointResponse struct {
  1287  	// ServerResponse contains the HTTP response code and headers from the
  1288  	// server.
  1289  	googleapi.ServerResponse `json:"-"`
  1290  }
  1291  
  1292  // Variable: Represents a variable or an argument possibly of a compound
  1293  // object type. Note how the following variables are represented: 1) A
  1294  // simple variable: int x = 5 { name: "x", value: "5", type: "int" } //
  1295  // Captured variable 2) A compound object: struct T { int m1; int m2; };
  1296  // T x = { 3, 7 }; { // Captured variable name: "x", type: "T", members
  1297  // { name: "m1", value: "3", type: "int" }, members { name: "m2", value:
  1298  // "7", type: "int" } } 3) A pointer where the pointee was captured: T x
  1299  // = { 3, 7 }; T* p = &x; { // Captured variable name: "p", type: "T*",
  1300  // value: "0x00500500", members { name: "m1", value: "3", type: "int" },
  1301  // members { name: "m2", value: "7", type: "int" } } 4) A pointer where
  1302  // the pointee was not captured: T* p = new T; { // Captured variable
  1303  // name: "p", type: "T*", value: "0x00400400" status { is_error: true,
  1304  // description { format: "unavailable" } } } The status should describe
  1305  // the reason for the missing value, such as “, “, “. Note that a
  1306  // null pointer should not have members. 5) An unnamed value: int* p =
  1307  // new int(7); { // Captured variable name: "p", value: "0x00500500",
  1308  // type: "int*", members { value: "7", type: "int" } } 6) An unnamed
  1309  // pointer where the pointee was not captured: int* p = new int(7);
  1310  // int** pp = &p; { // Captured variable name: "pp", value:
  1311  // "0x00500500", type: "int**", members { value: "0x00400400", type:
  1312  // "int*" status { is_error: true, description: { format: "unavailable"
  1313  // } } } } } To optimize computation, memory and network traffic,
  1314  // variables that repeat in the output multiple times can be stored once
  1315  // in a shared variable table and be referenced using the
  1316  // `var_table_index` field. The variables stored in the shared table are
  1317  // nameless and are essentially a partition of the complete variable. To
  1318  // reconstruct the complete variable, merge the referencing variable
  1319  // with the referenced variable. When using the shared variable table,
  1320  // the following variables: T x = { 3, 7 }; T* p = &x; T& r = x; { name:
  1321  // "x", var_table_index: 3, type: "T" } // Captured variables { name:
  1322  // "p", value "0x00500500", type="T*", var_table_index: 3 } { name: "r",
  1323  // type="T&", var_table_index: 3 } { // Shared variable table entry #3:
  1324  // members { name: "m1", value: "3", type: "int" }, members { name:
  1325  // "m2", value: "7", type: "int" } } Note that the pointer address is
  1326  // stored with the referencing variable and not with the referenced
  1327  // variable. This allows the referenced variable to be shared between
  1328  // pointers and references. The type field is optional. The debugger
  1329  // agent may or may not support it.
  1330  type Variable struct {
  1331  	// Members: Members contained or pointed to by the variable.
  1332  	Members []*Variable `json:"members,omitempty"`
  1333  
  1334  	// Name: Name of the variable, if any.
  1335  	Name string `json:"name,omitempty"`
  1336  
  1337  	// Status: Status associated with the variable. This field will usually
  1338  	// stay unset. A status of a single variable only applies to that
  1339  	// variable or expression. The rest of breakpoint data still remains
  1340  	// valid. Variables might be reported in error state even when
  1341  	// breakpoint is not in final state. The message may refer to variable
  1342  	// name with `refers_to` set to `VARIABLE_NAME`. Alternatively
  1343  	// `refers_to` will be set to `VARIABLE_VALUE`. In either case variable
  1344  	// value and members will be unset. Example of error message applied to
  1345  	// name: `Invalid expression syntax`. Example of information message
  1346  	// applied to value: `Not captured`. Examples of error message applied
  1347  	// to value: * `Malformed string`, * `Field f not found in class C` *
  1348  	// `Null pointer dereference`
  1349  	Status *StatusMessage `json:"status,omitempty"`
  1350  
  1351  	// Type: Variable type (e.g. `MyClass`). If the variable is split with
  1352  	// `var_table_index`, `type` goes next to `value`. The interpretation of
  1353  	// a type is agent specific. It is recommended to include the dynamic
  1354  	// type rather than a static type of an object.
  1355  	Type string `json:"type,omitempty"`
  1356  
  1357  	// Value: Simple value of the variable.
  1358  	Value string `json:"value,omitempty"`
  1359  
  1360  	// VarTableIndex: Reference to a variable in the shared variable table.
  1361  	// More than one variable can reference the same variable in the table.
  1362  	// The `var_table_index` field is an index into `variable_table` in
  1363  	// Breakpoint.
  1364  	VarTableIndex int64 `json:"varTableIndex,omitempty"`
  1365  
  1366  	// ForceSendFields is a list of field names (e.g. "Members") to
  1367  	// unconditionally include in API requests. By default, fields with
  1368  	// empty or default values are omitted from API requests. However, any
  1369  	// non-pointer, non-interface field appearing in ForceSendFields will be
  1370  	// sent to the server regardless of whether the field is empty or not.
  1371  	// This may be used to include empty fields in Patch requests.
  1372  	ForceSendFields []string `json:"-"`
  1373  
  1374  	// NullFields is a list of field names (e.g. "Members") to include in
  1375  	// API requests with the JSON null value. By default, fields with empty
  1376  	// values are omitted from API requests. However, any field with an
  1377  	// empty value appearing in NullFields will be sent to the server as
  1378  	// null. It is an error if a field in this list has a non-empty value.
  1379  	// This may be used to include null fields in Patch requests.
  1380  	NullFields []string `json:"-"`
  1381  }
  1382  
  1383  func (s *Variable) MarshalJSON() ([]byte, error) {
  1384  	type NoMethod Variable
  1385  	raw := NoMethod(*s)
  1386  	return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields)
  1387  }
  1388  
  1389  // method id "clouddebugger.controller.debuggees.register":
  1390  
  1391  type ControllerDebuggeesRegisterCall struct {
  1392  	s                       *Service
  1393  	registerdebuggeerequest *RegisterDebuggeeRequest
  1394  	urlParams_              gensupport.URLParams
  1395  	ctx_                    context.Context
  1396  	header_                 http.Header
  1397  }
  1398  
  1399  // Register: Registers the debuggee with the controller service. All
  1400  // agents attached to the same application must call this method with
  1401  // exactly the same request content to get back the same stable
  1402  // `debuggee_id`. Agents should call this method again whenever
  1403  // `google.rpc.Code.NOT_FOUND` is returned from any controller method.
  1404  // This protocol allows the controller service to disable debuggees,
  1405  // recover from data loss, or change the `debuggee_id` format. Agents
  1406  // must handle `debuggee_id` value changing upon re-registration.
  1407  func (r *ControllerDebuggeesService) Register(registerdebuggeerequest *RegisterDebuggeeRequest) *ControllerDebuggeesRegisterCall {
  1408  	c := &ControllerDebuggeesRegisterCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1409  	c.registerdebuggeerequest = registerdebuggeerequest
  1410  	return c
  1411  }
  1412  
  1413  // Fields allows partial responses to be retrieved. See
  1414  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1415  // for more information.
  1416  func (c *ControllerDebuggeesRegisterCall) Fields(s ...googleapi.Field) *ControllerDebuggeesRegisterCall {
  1417  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1418  	return c
  1419  }
  1420  
  1421  // Context sets the context to be used in this call's Do method. Any
  1422  // pending HTTP request will be aborted if the provided context is
  1423  // canceled.
  1424  func (c *ControllerDebuggeesRegisterCall) Context(ctx context.Context) *ControllerDebuggeesRegisterCall {
  1425  	c.ctx_ = ctx
  1426  	return c
  1427  }
  1428  
  1429  // Header returns an http.Header that can be modified by the caller to
  1430  // add HTTP headers to the request.
  1431  func (c *ControllerDebuggeesRegisterCall) Header() http.Header {
  1432  	if c.header_ == nil {
  1433  		c.header_ = make(http.Header)
  1434  	}
  1435  	return c.header_
  1436  }
  1437  
  1438  func (c *ControllerDebuggeesRegisterCall) doRequest(alt string) (*http.Response, error) {
  1439  	reqHeaders := make(http.Header)
  1440  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  1441  	for k, v := range c.header_ {
  1442  		reqHeaders[k] = v
  1443  	}
  1444  	reqHeaders.Set("User-Agent", c.s.userAgent())
  1445  	var body io.Reader = nil
  1446  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.registerdebuggeerequest)
  1447  	if err != nil {
  1448  		return nil, err
  1449  	}
  1450  	reqHeaders.Set("Content-Type", "application/json")
  1451  	c.urlParams_.Set("alt", alt)
  1452  	c.urlParams_.Set("prettyPrint", "false")
  1453  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/register")
  1454  	urls += "?" + c.urlParams_.Encode()
  1455  	req, err := http.NewRequest("POST", urls, body)
  1456  	if err != nil {
  1457  		return nil, err
  1458  	}
  1459  	req.Header = reqHeaders
  1460  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1461  }
  1462  
  1463  // Do executes the "clouddebugger.controller.debuggees.register" call.
  1464  // Exactly one of *RegisterDebuggeeResponse or error will be non-nil.
  1465  // Any non-2xx status code is an error. Response headers are in either
  1466  // *RegisterDebuggeeResponse.ServerResponse.Header or (if a response was
  1467  // returned at all) in error.(*googleapi.Error).Header. Use
  1468  // googleapi.IsNotModified to check whether the returned error was
  1469  // because http.StatusNotModified was returned.
  1470  func (c *ControllerDebuggeesRegisterCall) Do(opts ...googleapi.CallOption) (*RegisterDebuggeeResponse, error) {
  1471  	gensupport.SetOptions(c.urlParams_, opts...)
  1472  	res, err := c.doRequest("json")
  1473  	if res != nil && res.StatusCode == http.StatusNotModified {
  1474  		if res.Body != nil {
  1475  			res.Body.Close()
  1476  		}
  1477  		return nil, gensupport.WrapError(&googleapi.Error{
  1478  			Code:   res.StatusCode,
  1479  			Header: res.Header,
  1480  		})
  1481  	}
  1482  	if err != nil {
  1483  		return nil, err
  1484  	}
  1485  	defer googleapi.CloseBody(res)
  1486  	if err := googleapi.CheckResponse(res); err != nil {
  1487  		return nil, gensupport.WrapError(err)
  1488  	}
  1489  	ret := &RegisterDebuggeeResponse{
  1490  		ServerResponse: googleapi.ServerResponse{
  1491  			Header:         res.Header,
  1492  			HTTPStatusCode: res.StatusCode,
  1493  		},
  1494  	}
  1495  	target := &ret
  1496  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1497  		return nil, err
  1498  	}
  1499  	return ret, nil
  1500  	// {
  1501  	//   "description": "Registers the debuggee with the controller service. All agents attached to the same application must call this method with exactly the same request content to get back the same stable `debuggee_id`. Agents should call this method again whenever `google.rpc.Code.NOT_FOUND` is returned from any controller method. This protocol allows the controller service to disable debuggees, recover from data loss, or change the `debuggee_id` format. Agents must handle `debuggee_id` value changing upon re-registration.",
  1502  	//   "flatPath": "v2/controller/debuggees/register",
  1503  	//   "httpMethod": "POST",
  1504  	//   "id": "clouddebugger.controller.debuggees.register",
  1505  	//   "parameterOrder": [],
  1506  	//   "parameters": {},
  1507  	//   "path": "v2/controller/debuggees/register",
  1508  	//   "request": {
  1509  	//     "$ref": "RegisterDebuggeeRequest"
  1510  	//   },
  1511  	//   "response": {
  1512  	//     "$ref": "RegisterDebuggeeResponse"
  1513  	//   },
  1514  	//   "scopes": [
  1515  	//     "https://www.googleapis.com/auth/cloud-platform",
  1516  	//     "https://www.googleapis.com/auth/cloud_debugger"
  1517  	//   ]
  1518  	// }
  1519  
  1520  }
  1521  
  1522  // method id "clouddebugger.controller.debuggees.breakpoints.list":
  1523  
  1524  type ControllerDebuggeesBreakpointsListCall struct {
  1525  	s            *Service
  1526  	debuggeeId   string
  1527  	urlParams_   gensupport.URLParams
  1528  	ifNoneMatch_ string
  1529  	ctx_         context.Context
  1530  	header_      http.Header
  1531  }
  1532  
  1533  // List: Returns the list of all active breakpoints for the debuggee.
  1534  // The breakpoint specification (`location`, `condition`, and
  1535  // `expressions` fields) is semantically immutable, although the field
  1536  // values may change. For example, an agent may update the location line
  1537  // number to reflect the actual line where the breakpoint was set, but
  1538  // this doesn't change the breakpoint semantics. This means that an
  1539  // agent does not need to check if a breakpoint has changed when it
  1540  // encounters the same breakpoint on a successive call. Moreover, an
  1541  // agent should remember the breakpoints that are completed until the
  1542  // controller removes them from the active list to avoid setting those
  1543  // breakpoints again.
  1544  //
  1545  // - debuggeeId: Identifies the debuggee.
  1546  func (r *ControllerDebuggeesBreakpointsService) List(debuggeeId string) *ControllerDebuggeesBreakpointsListCall {
  1547  	c := &ControllerDebuggeesBreakpointsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1548  	c.debuggeeId = debuggeeId
  1549  	return c
  1550  }
  1551  
  1552  // AgentId sets the optional parameter "agentId": Identifies the agent.
  1553  // This is the ID returned in the RegisterDebuggee response.
  1554  func (c *ControllerDebuggeesBreakpointsListCall) AgentId(agentId string) *ControllerDebuggeesBreakpointsListCall {
  1555  	c.urlParams_.Set("agentId", agentId)
  1556  	return c
  1557  }
  1558  
  1559  // SuccessOnTimeout sets the optional parameter "successOnTimeout": If
  1560  // set to `true` (recommended), returns `google.rpc.Code.OK` status and
  1561  // sets the `wait_expired` response field to `true` when the
  1562  // server-selected timeout has expired. If set to `false` (deprecated),
  1563  // returns `google.rpc.Code.ABORTED` status when the server-selected
  1564  // timeout has expired.
  1565  func (c *ControllerDebuggeesBreakpointsListCall) SuccessOnTimeout(successOnTimeout bool) *ControllerDebuggeesBreakpointsListCall {
  1566  	c.urlParams_.Set("successOnTimeout", fmt.Sprint(successOnTimeout))
  1567  	return c
  1568  }
  1569  
  1570  // WaitToken sets the optional parameter "waitToken": A token that, if
  1571  // specified, blocks the method call until the list of active
  1572  // breakpoints has changed, or a server-selected timeout has expired.
  1573  // The value should be set from the `next_wait_token` field in the last
  1574  // response. The initial value should be set to "init".
  1575  func (c *ControllerDebuggeesBreakpointsListCall) WaitToken(waitToken string) *ControllerDebuggeesBreakpointsListCall {
  1576  	c.urlParams_.Set("waitToken", waitToken)
  1577  	return c
  1578  }
  1579  
  1580  // Fields allows partial responses to be retrieved. See
  1581  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1582  // for more information.
  1583  func (c *ControllerDebuggeesBreakpointsListCall) Fields(s ...googleapi.Field) *ControllerDebuggeesBreakpointsListCall {
  1584  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1585  	return c
  1586  }
  1587  
  1588  // IfNoneMatch sets the optional parameter which makes the operation
  1589  // fail if the object's ETag matches the given value. This is useful for
  1590  // getting updates only after the object has changed since the last
  1591  // request. Use googleapi.IsNotModified to check whether the response
  1592  // error from Do is the result of In-None-Match.
  1593  func (c *ControllerDebuggeesBreakpointsListCall) IfNoneMatch(entityTag string) *ControllerDebuggeesBreakpointsListCall {
  1594  	c.ifNoneMatch_ = entityTag
  1595  	return c
  1596  }
  1597  
  1598  // Context sets the context to be used in this call's Do method. Any
  1599  // pending HTTP request will be aborted if the provided context is
  1600  // canceled.
  1601  func (c *ControllerDebuggeesBreakpointsListCall) Context(ctx context.Context) *ControllerDebuggeesBreakpointsListCall {
  1602  	c.ctx_ = ctx
  1603  	return c
  1604  }
  1605  
  1606  // Header returns an http.Header that can be modified by the caller to
  1607  // add HTTP headers to the request.
  1608  func (c *ControllerDebuggeesBreakpointsListCall) Header() http.Header {
  1609  	if c.header_ == nil {
  1610  		c.header_ = make(http.Header)
  1611  	}
  1612  	return c.header_
  1613  }
  1614  
  1615  func (c *ControllerDebuggeesBreakpointsListCall) doRequest(alt string) (*http.Response, error) {
  1616  	reqHeaders := make(http.Header)
  1617  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  1618  	for k, v := range c.header_ {
  1619  		reqHeaders[k] = v
  1620  	}
  1621  	reqHeaders.Set("User-Agent", c.s.userAgent())
  1622  	if c.ifNoneMatch_ != "" {
  1623  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1624  	}
  1625  	var body io.Reader = nil
  1626  	c.urlParams_.Set("alt", alt)
  1627  	c.urlParams_.Set("prettyPrint", "false")
  1628  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/{debuggeeId}/breakpoints")
  1629  	urls += "?" + c.urlParams_.Encode()
  1630  	req, err := http.NewRequest("GET", urls, body)
  1631  	if err != nil {
  1632  		return nil, err
  1633  	}
  1634  	req.Header = reqHeaders
  1635  	googleapi.Expand(req.URL, map[string]string{
  1636  		"debuggeeId": c.debuggeeId,
  1637  	})
  1638  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1639  }
  1640  
  1641  // Do executes the "clouddebugger.controller.debuggees.breakpoints.list" call.
  1642  // Exactly one of *ListActiveBreakpointsResponse or error will be
  1643  // non-nil. Any non-2xx status code is an error. Response headers are in
  1644  // either *ListActiveBreakpointsResponse.ServerResponse.Header or (if a
  1645  // response was returned at all) in error.(*googleapi.Error).Header. Use
  1646  // googleapi.IsNotModified to check whether the returned error was
  1647  // because http.StatusNotModified was returned.
  1648  func (c *ControllerDebuggeesBreakpointsListCall) Do(opts ...googleapi.CallOption) (*ListActiveBreakpointsResponse, error) {
  1649  	gensupport.SetOptions(c.urlParams_, opts...)
  1650  	res, err := c.doRequest("json")
  1651  	if res != nil && res.StatusCode == http.StatusNotModified {
  1652  		if res.Body != nil {
  1653  			res.Body.Close()
  1654  		}
  1655  		return nil, gensupport.WrapError(&googleapi.Error{
  1656  			Code:   res.StatusCode,
  1657  			Header: res.Header,
  1658  		})
  1659  	}
  1660  	if err != nil {
  1661  		return nil, err
  1662  	}
  1663  	defer googleapi.CloseBody(res)
  1664  	if err := googleapi.CheckResponse(res); err != nil {
  1665  		return nil, gensupport.WrapError(err)
  1666  	}
  1667  	ret := &ListActiveBreakpointsResponse{
  1668  		ServerResponse: googleapi.ServerResponse{
  1669  			Header:         res.Header,
  1670  			HTTPStatusCode: res.StatusCode,
  1671  		},
  1672  	}
  1673  	target := &ret
  1674  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1675  		return nil, err
  1676  	}
  1677  	return ret, nil
  1678  	// {
  1679  	//   "description": "Returns the list of all active breakpoints for the debuggee. The breakpoint specification (`location`, `condition`, and `expressions` fields) is semantically immutable, although the field values may change. For example, an agent may update the location line number to reflect the actual line where the breakpoint was set, but this doesn't change the breakpoint semantics. This means that an agent does not need to check if a breakpoint has changed when it encounters the same breakpoint on a successive call. Moreover, an agent should remember the breakpoints that are completed until the controller removes them from the active list to avoid setting those breakpoints again.",
  1680  	//   "flatPath": "v2/controller/debuggees/{debuggeeId}/breakpoints",
  1681  	//   "httpMethod": "GET",
  1682  	//   "id": "clouddebugger.controller.debuggees.breakpoints.list",
  1683  	//   "parameterOrder": [
  1684  	//     "debuggeeId"
  1685  	//   ],
  1686  	//   "parameters": {
  1687  	//     "agentId": {
  1688  	//       "description": "Identifies the agent. This is the ID returned in the RegisterDebuggee response.",
  1689  	//       "location": "query",
  1690  	//       "type": "string"
  1691  	//     },
  1692  	//     "debuggeeId": {
  1693  	//       "description": "Required. Identifies the debuggee.",
  1694  	//       "location": "path",
  1695  	//       "required": true,
  1696  	//       "type": "string"
  1697  	//     },
  1698  	//     "successOnTimeout": {
  1699  	//       "description": "If set to `true` (recommended), returns `google.rpc.Code.OK` status and sets the `wait_expired` response field to `true` when the server-selected timeout has expired. If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status when the server-selected timeout has expired.",
  1700  	//       "location": "query",
  1701  	//       "type": "boolean"
  1702  	//     },
  1703  	//     "waitToken": {
  1704  	//       "description": "A token that, if specified, blocks the method call until the list of active breakpoints has changed, or a server-selected timeout has expired. The value should be set from the `next_wait_token` field in the last response. The initial value should be set to `\"init\"`.",
  1705  	//       "location": "query",
  1706  	//       "type": "string"
  1707  	//     }
  1708  	//   },
  1709  	//   "path": "v2/controller/debuggees/{debuggeeId}/breakpoints",
  1710  	//   "response": {
  1711  	//     "$ref": "ListActiveBreakpointsResponse"
  1712  	//   },
  1713  	//   "scopes": [
  1714  	//     "https://www.googleapis.com/auth/cloud-platform",
  1715  	//     "https://www.googleapis.com/auth/cloud_debugger"
  1716  	//   ]
  1717  	// }
  1718  
  1719  }
  1720  
  1721  // method id "clouddebugger.controller.debuggees.breakpoints.update":
  1722  
  1723  type ControllerDebuggeesBreakpointsUpdateCall struct {
  1724  	s                             *Service
  1725  	debuggeeId                    string
  1726  	id                            string
  1727  	updateactivebreakpointrequest *UpdateActiveBreakpointRequest
  1728  	urlParams_                    gensupport.URLParams
  1729  	ctx_                          context.Context
  1730  	header_                       http.Header
  1731  }
  1732  
  1733  // Update: Updates the breakpoint state or mutable fields. The entire
  1734  // Breakpoint message must be sent back to the controller service.
  1735  // Updates to active breakpoint fields are only allowed if the new value
  1736  // does not change the breakpoint specification. Updates to the
  1737  // `location`, `condition` and `expressions` fields should not alter the
  1738  // breakpoint semantics. These may only make changes such as
  1739  // canonicalizing a value or snapping the location to the correct line
  1740  // of code.
  1741  //
  1742  // - debuggeeId: Identifies the debuggee being debugged.
  1743  // - id: Breakpoint identifier, unique in the scope of the debuggee.
  1744  func (r *ControllerDebuggeesBreakpointsService) Update(debuggeeId string, id string, updateactivebreakpointrequest *UpdateActiveBreakpointRequest) *ControllerDebuggeesBreakpointsUpdateCall {
  1745  	c := &ControllerDebuggeesBreakpointsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1746  	c.debuggeeId = debuggeeId
  1747  	c.id = id
  1748  	c.updateactivebreakpointrequest = updateactivebreakpointrequest
  1749  	return c
  1750  }
  1751  
  1752  // Fields allows partial responses to be retrieved. See
  1753  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1754  // for more information.
  1755  func (c *ControllerDebuggeesBreakpointsUpdateCall) Fields(s ...googleapi.Field) *ControllerDebuggeesBreakpointsUpdateCall {
  1756  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1757  	return c
  1758  }
  1759  
  1760  // Context sets the context to be used in this call's Do method. Any
  1761  // pending HTTP request will be aborted if the provided context is
  1762  // canceled.
  1763  func (c *ControllerDebuggeesBreakpointsUpdateCall) Context(ctx context.Context) *ControllerDebuggeesBreakpointsUpdateCall {
  1764  	c.ctx_ = ctx
  1765  	return c
  1766  }
  1767  
  1768  // Header returns an http.Header that can be modified by the caller to
  1769  // add HTTP headers to the request.
  1770  func (c *ControllerDebuggeesBreakpointsUpdateCall) Header() http.Header {
  1771  	if c.header_ == nil {
  1772  		c.header_ = make(http.Header)
  1773  	}
  1774  	return c.header_
  1775  }
  1776  
  1777  func (c *ControllerDebuggeesBreakpointsUpdateCall) doRequest(alt string) (*http.Response, error) {
  1778  	reqHeaders := make(http.Header)
  1779  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  1780  	for k, v := range c.header_ {
  1781  		reqHeaders[k] = v
  1782  	}
  1783  	reqHeaders.Set("User-Agent", c.s.userAgent())
  1784  	var body io.Reader = nil
  1785  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.updateactivebreakpointrequest)
  1786  	if err != nil {
  1787  		return nil, err
  1788  	}
  1789  	reqHeaders.Set("Content-Type", "application/json")
  1790  	c.urlParams_.Set("alt", alt)
  1791  	c.urlParams_.Set("prettyPrint", "false")
  1792  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}")
  1793  	urls += "?" + c.urlParams_.Encode()
  1794  	req, err := http.NewRequest("PUT", urls, body)
  1795  	if err != nil {
  1796  		return nil, err
  1797  	}
  1798  	req.Header = reqHeaders
  1799  	googleapi.Expand(req.URL, map[string]string{
  1800  		"debuggeeId": c.debuggeeId,
  1801  		"id":         c.id,
  1802  	})
  1803  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1804  }
  1805  
  1806  // Do executes the "clouddebugger.controller.debuggees.breakpoints.update" call.
  1807  // Exactly one of *UpdateActiveBreakpointResponse or error will be
  1808  // non-nil. Any non-2xx status code is an error. Response headers are in
  1809  // either *UpdateActiveBreakpointResponse.ServerResponse.Header or (if a
  1810  // response was returned at all) in error.(*googleapi.Error).Header. Use
  1811  // googleapi.IsNotModified to check whether the returned error was
  1812  // because http.StatusNotModified was returned.
  1813  func (c *ControllerDebuggeesBreakpointsUpdateCall) Do(opts ...googleapi.CallOption) (*UpdateActiveBreakpointResponse, error) {
  1814  	gensupport.SetOptions(c.urlParams_, opts...)
  1815  	res, err := c.doRequest("json")
  1816  	if res != nil && res.StatusCode == http.StatusNotModified {
  1817  		if res.Body != nil {
  1818  			res.Body.Close()
  1819  		}
  1820  		return nil, gensupport.WrapError(&googleapi.Error{
  1821  			Code:   res.StatusCode,
  1822  			Header: res.Header,
  1823  		})
  1824  	}
  1825  	if err != nil {
  1826  		return nil, err
  1827  	}
  1828  	defer googleapi.CloseBody(res)
  1829  	if err := googleapi.CheckResponse(res); err != nil {
  1830  		return nil, gensupport.WrapError(err)
  1831  	}
  1832  	ret := &UpdateActiveBreakpointResponse{
  1833  		ServerResponse: googleapi.ServerResponse{
  1834  			Header:         res.Header,
  1835  			HTTPStatusCode: res.StatusCode,
  1836  		},
  1837  	}
  1838  	target := &ret
  1839  	if err := gensupport.DecodeResponse(target, res); err != nil {
  1840  		return nil, err
  1841  	}
  1842  	return ret, nil
  1843  	// {
  1844  	//   "description": "Updates the breakpoint state or mutable fields. The entire Breakpoint message must be sent back to the controller service. Updates to active breakpoint fields are only allowed if the new value does not change the breakpoint specification. Updates to the `location`, `condition` and `expressions` fields should not alter the breakpoint semantics. These may only make changes such as canonicalizing a value or snapping the location to the correct line of code.",
  1845  	//   "flatPath": "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}",
  1846  	//   "httpMethod": "PUT",
  1847  	//   "id": "clouddebugger.controller.debuggees.breakpoints.update",
  1848  	//   "parameterOrder": [
  1849  	//     "debuggeeId",
  1850  	//     "id"
  1851  	//   ],
  1852  	//   "parameters": {
  1853  	//     "debuggeeId": {
  1854  	//       "description": "Required. Identifies the debuggee being debugged.",
  1855  	//       "location": "path",
  1856  	//       "required": true,
  1857  	//       "type": "string"
  1858  	//     },
  1859  	//     "id": {
  1860  	//       "description": "Breakpoint identifier, unique in the scope of the debuggee.",
  1861  	//       "location": "path",
  1862  	//       "required": true,
  1863  	//       "type": "string"
  1864  	//     }
  1865  	//   },
  1866  	//   "path": "v2/controller/debuggees/{debuggeeId}/breakpoints/{id}",
  1867  	//   "request": {
  1868  	//     "$ref": "UpdateActiveBreakpointRequest"
  1869  	//   },
  1870  	//   "response": {
  1871  	//     "$ref": "UpdateActiveBreakpointResponse"
  1872  	//   },
  1873  	//   "scopes": [
  1874  	//     "https://www.googleapis.com/auth/cloud-platform",
  1875  	//     "https://www.googleapis.com/auth/cloud_debugger"
  1876  	//   ]
  1877  	// }
  1878  
  1879  }
  1880  
  1881  // method id "clouddebugger.debugger.debuggees.list":
  1882  
  1883  type DebuggerDebuggeesListCall struct {
  1884  	s            *Service
  1885  	urlParams_   gensupport.URLParams
  1886  	ifNoneMatch_ string
  1887  	ctx_         context.Context
  1888  	header_      http.Header
  1889  }
  1890  
  1891  // List: Lists all the debuggees that the user has access to.
  1892  func (r *DebuggerDebuggeesService) List() *DebuggerDebuggeesListCall {
  1893  	c := &DebuggerDebuggeesListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  1894  	return c
  1895  }
  1896  
  1897  // ClientVersion sets the optional parameter "clientVersion": Required.
  1898  // The client version making the call. Schema: `domain/type/version`
  1899  // (e.g., `google.com/intellij/v1`).
  1900  func (c *DebuggerDebuggeesListCall) ClientVersion(clientVersion string) *DebuggerDebuggeesListCall {
  1901  	c.urlParams_.Set("clientVersion", clientVersion)
  1902  	return c
  1903  }
  1904  
  1905  // IncludeInactive sets the optional parameter "includeInactive": When
  1906  // set to `true`, the result includes all debuggees. Otherwise, the
  1907  // result includes only debuggees that are active.
  1908  func (c *DebuggerDebuggeesListCall) IncludeInactive(includeInactive bool) *DebuggerDebuggeesListCall {
  1909  	c.urlParams_.Set("includeInactive", fmt.Sprint(includeInactive))
  1910  	return c
  1911  }
  1912  
  1913  // Project sets the optional parameter "project": Required. Project
  1914  // number of a Google Cloud project whose debuggees to list.
  1915  func (c *DebuggerDebuggeesListCall) Project(project string) *DebuggerDebuggeesListCall {
  1916  	c.urlParams_.Set("project", project)
  1917  	return c
  1918  }
  1919  
  1920  // Fields allows partial responses to be retrieved. See
  1921  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  1922  // for more information.
  1923  func (c *DebuggerDebuggeesListCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesListCall {
  1924  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  1925  	return c
  1926  }
  1927  
  1928  // IfNoneMatch sets the optional parameter which makes the operation
  1929  // fail if the object's ETag matches the given value. This is useful for
  1930  // getting updates only after the object has changed since the last
  1931  // request. Use googleapi.IsNotModified to check whether the response
  1932  // error from Do is the result of In-None-Match.
  1933  func (c *DebuggerDebuggeesListCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesListCall {
  1934  	c.ifNoneMatch_ = entityTag
  1935  	return c
  1936  }
  1937  
  1938  // Context sets the context to be used in this call's Do method. Any
  1939  // pending HTTP request will be aborted if the provided context is
  1940  // canceled.
  1941  func (c *DebuggerDebuggeesListCall) Context(ctx context.Context) *DebuggerDebuggeesListCall {
  1942  	c.ctx_ = ctx
  1943  	return c
  1944  }
  1945  
  1946  // Header returns an http.Header that can be modified by the caller to
  1947  // add HTTP headers to the request.
  1948  func (c *DebuggerDebuggeesListCall) Header() http.Header {
  1949  	if c.header_ == nil {
  1950  		c.header_ = make(http.Header)
  1951  	}
  1952  	return c.header_
  1953  }
  1954  
  1955  func (c *DebuggerDebuggeesListCall) doRequest(alt string) (*http.Response, error) {
  1956  	reqHeaders := make(http.Header)
  1957  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  1958  	for k, v := range c.header_ {
  1959  		reqHeaders[k] = v
  1960  	}
  1961  	reqHeaders.Set("User-Agent", c.s.userAgent())
  1962  	if c.ifNoneMatch_ != "" {
  1963  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  1964  	}
  1965  	var body io.Reader = nil
  1966  	c.urlParams_.Set("alt", alt)
  1967  	c.urlParams_.Set("prettyPrint", "false")
  1968  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees")
  1969  	urls += "?" + c.urlParams_.Encode()
  1970  	req, err := http.NewRequest("GET", urls, body)
  1971  	if err != nil {
  1972  		return nil, err
  1973  	}
  1974  	req.Header = reqHeaders
  1975  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  1976  }
  1977  
  1978  // Do executes the "clouddebugger.debugger.debuggees.list" call.
  1979  // Exactly one of *ListDebuggeesResponse or error will be non-nil. Any
  1980  // non-2xx status code is an error. Response headers are in either
  1981  // *ListDebuggeesResponse.ServerResponse.Header or (if a response was
  1982  // returned at all) in error.(*googleapi.Error).Header. Use
  1983  // googleapi.IsNotModified to check whether the returned error was
  1984  // because http.StatusNotModified was returned.
  1985  func (c *DebuggerDebuggeesListCall) Do(opts ...googleapi.CallOption) (*ListDebuggeesResponse, error) {
  1986  	gensupport.SetOptions(c.urlParams_, opts...)
  1987  	res, err := c.doRequest("json")
  1988  	if res != nil && res.StatusCode == http.StatusNotModified {
  1989  		if res.Body != nil {
  1990  			res.Body.Close()
  1991  		}
  1992  		return nil, gensupport.WrapError(&googleapi.Error{
  1993  			Code:   res.StatusCode,
  1994  			Header: res.Header,
  1995  		})
  1996  	}
  1997  	if err != nil {
  1998  		return nil, err
  1999  	}
  2000  	defer googleapi.CloseBody(res)
  2001  	if err := googleapi.CheckResponse(res); err != nil {
  2002  		return nil, gensupport.WrapError(err)
  2003  	}
  2004  	ret := &ListDebuggeesResponse{
  2005  		ServerResponse: googleapi.ServerResponse{
  2006  			Header:         res.Header,
  2007  			HTTPStatusCode: res.StatusCode,
  2008  		},
  2009  	}
  2010  	target := &ret
  2011  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2012  		return nil, err
  2013  	}
  2014  	return ret, nil
  2015  	// {
  2016  	//   "description": "Lists all the debuggees that the user has access to.",
  2017  	//   "flatPath": "v2/debugger/debuggees",
  2018  	//   "httpMethod": "GET",
  2019  	//   "id": "clouddebugger.debugger.debuggees.list",
  2020  	//   "parameterOrder": [],
  2021  	//   "parameters": {
  2022  	//     "clientVersion": {
  2023  	//       "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).",
  2024  	//       "location": "query",
  2025  	//       "type": "string"
  2026  	//     },
  2027  	//     "includeInactive": {
  2028  	//       "description": "When set to `true`, the result includes all debuggees. Otherwise, the result includes only debuggees that are active.",
  2029  	//       "location": "query",
  2030  	//       "type": "boolean"
  2031  	//     },
  2032  	//     "project": {
  2033  	//       "description": "Required. Project number of a Google Cloud project whose debuggees to list.",
  2034  	//       "location": "query",
  2035  	//       "type": "string"
  2036  	//     }
  2037  	//   },
  2038  	//   "path": "v2/debugger/debuggees",
  2039  	//   "response": {
  2040  	//     "$ref": "ListDebuggeesResponse"
  2041  	//   },
  2042  	//   "scopes": [
  2043  	//     "https://www.googleapis.com/auth/cloud-platform",
  2044  	//     "https://www.googleapis.com/auth/cloud_debugger"
  2045  	//   ]
  2046  	// }
  2047  
  2048  }
  2049  
  2050  // method id "clouddebugger.debugger.debuggees.breakpoints.delete":
  2051  
  2052  type DebuggerDebuggeesBreakpointsDeleteCall struct {
  2053  	s            *Service
  2054  	debuggeeId   string
  2055  	breakpointId string
  2056  	urlParams_   gensupport.URLParams
  2057  	ctx_         context.Context
  2058  	header_      http.Header
  2059  }
  2060  
  2061  // Delete: Deletes the breakpoint from the debuggee.
  2062  //
  2063  // - breakpointId: ID of the breakpoint to delete.
  2064  // - debuggeeId: ID of the debuggee whose breakpoint to delete.
  2065  func (r *DebuggerDebuggeesBreakpointsService) Delete(debuggeeId string, breakpointId string) *DebuggerDebuggeesBreakpointsDeleteCall {
  2066  	c := &DebuggerDebuggeesBreakpointsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2067  	c.debuggeeId = debuggeeId
  2068  	c.breakpointId = breakpointId
  2069  	return c
  2070  }
  2071  
  2072  // ClientVersion sets the optional parameter "clientVersion": Required.
  2073  // The client version making the call. Schema: `domain/type/version`
  2074  // (e.g., `google.com/intellij/v1`).
  2075  func (c *DebuggerDebuggeesBreakpointsDeleteCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsDeleteCall {
  2076  	c.urlParams_.Set("clientVersion", clientVersion)
  2077  	return c
  2078  }
  2079  
  2080  // Fields allows partial responses to be retrieved. See
  2081  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2082  // for more information.
  2083  func (c *DebuggerDebuggeesBreakpointsDeleteCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsDeleteCall {
  2084  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2085  	return c
  2086  }
  2087  
  2088  // Context sets the context to be used in this call's Do method. Any
  2089  // pending HTTP request will be aborted if the provided context is
  2090  // canceled.
  2091  func (c *DebuggerDebuggeesBreakpointsDeleteCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsDeleteCall {
  2092  	c.ctx_ = ctx
  2093  	return c
  2094  }
  2095  
  2096  // Header returns an http.Header that can be modified by the caller to
  2097  // add HTTP headers to the request.
  2098  func (c *DebuggerDebuggeesBreakpointsDeleteCall) Header() http.Header {
  2099  	if c.header_ == nil {
  2100  		c.header_ = make(http.Header)
  2101  	}
  2102  	return c.header_
  2103  }
  2104  
  2105  func (c *DebuggerDebuggeesBreakpointsDeleteCall) doRequest(alt string) (*http.Response, error) {
  2106  	reqHeaders := make(http.Header)
  2107  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  2108  	for k, v := range c.header_ {
  2109  		reqHeaders[k] = v
  2110  	}
  2111  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2112  	var body io.Reader = nil
  2113  	c.urlParams_.Set("alt", alt)
  2114  	c.urlParams_.Set("prettyPrint", "false")
  2115  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}")
  2116  	urls += "?" + c.urlParams_.Encode()
  2117  	req, err := http.NewRequest("DELETE", urls, body)
  2118  	if err != nil {
  2119  		return nil, err
  2120  	}
  2121  	req.Header = reqHeaders
  2122  	googleapi.Expand(req.URL, map[string]string{
  2123  		"debuggeeId":   c.debuggeeId,
  2124  		"breakpointId": c.breakpointId,
  2125  	})
  2126  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2127  }
  2128  
  2129  // Do executes the "clouddebugger.debugger.debuggees.breakpoints.delete" call.
  2130  // Exactly one of *Empty or error will be non-nil. Any non-2xx status
  2131  // code is an error. Response headers are in either
  2132  // *Empty.ServerResponse.Header or (if a response was returned at all)
  2133  // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to
  2134  // check whether the returned error was because http.StatusNotModified
  2135  // was returned.
  2136  func (c *DebuggerDebuggeesBreakpointsDeleteCall) Do(opts ...googleapi.CallOption) (*Empty, error) {
  2137  	gensupport.SetOptions(c.urlParams_, opts...)
  2138  	res, err := c.doRequest("json")
  2139  	if res != nil && res.StatusCode == http.StatusNotModified {
  2140  		if res.Body != nil {
  2141  			res.Body.Close()
  2142  		}
  2143  		return nil, gensupport.WrapError(&googleapi.Error{
  2144  			Code:   res.StatusCode,
  2145  			Header: res.Header,
  2146  		})
  2147  	}
  2148  	if err != nil {
  2149  		return nil, err
  2150  	}
  2151  	defer googleapi.CloseBody(res)
  2152  	if err := googleapi.CheckResponse(res); err != nil {
  2153  		return nil, gensupport.WrapError(err)
  2154  	}
  2155  	ret := &Empty{
  2156  		ServerResponse: googleapi.ServerResponse{
  2157  			Header:         res.Header,
  2158  			HTTPStatusCode: res.StatusCode,
  2159  		},
  2160  	}
  2161  	target := &ret
  2162  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2163  		return nil, err
  2164  	}
  2165  	return ret, nil
  2166  	// {
  2167  	//   "description": "Deletes the breakpoint from the debuggee.",
  2168  	//   "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}",
  2169  	//   "httpMethod": "DELETE",
  2170  	//   "id": "clouddebugger.debugger.debuggees.breakpoints.delete",
  2171  	//   "parameterOrder": [
  2172  	//     "debuggeeId",
  2173  	//     "breakpointId"
  2174  	//   ],
  2175  	//   "parameters": {
  2176  	//     "breakpointId": {
  2177  	//       "description": "Required. ID of the breakpoint to delete.",
  2178  	//       "location": "path",
  2179  	//       "required": true,
  2180  	//       "type": "string"
  2181  	//     },
  2182  	//     "clientVersion": {
  2183  	//       "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).",
  2184  	//       "location": "query",
  2185  	//       "type": "string"
  2186  	//     },
  2187  	//     "debuggeeId": {
  2188  	//       "description": "Required. ID of the debuggee whose breakpoint to delete.",
  2189  	//       "location": "path",
  2190  	//       "required": true,
  2191  	//       "type": "string"
  2192  	//     }
  2193  	//   },
  2194  	//   "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}",
  2195  	//   "response": {
  2196  	//     "$ref": "Empty"
  2197  	//   },
  2198  	//   "scopes": [
  2199  	//     "https://www.googleapis.com/auth/cloud-platform",
  2200  	//     "https://www.googleapis.com/auth/cloud_debugger"
  2201  	//   ]
  2202  	// }
  2203  
  2204  }
  2205  
  2206  // method id "clouddebugger.debugger.debuggees.breakpoints.get":
  2207  
  2208  type DebuggerDebuggeesBreakpointsGetCall struct {
  2209  	s            *Service
  2210  	debuggeeId   string
  2211  	breakpointId string
  2212  	urlParams_   gensupport.URLParams
  2213  	ifNoneMatch_ string
  2214  	ctx_         context.Context
  2215  	header_      http.Header
  2216  }
  2217  
  2218  // Get: Gets breakpoint information.
  2219  //
  2220  // - breakpointId: ID of the breakpoint to get.
  2221  // - debuggeeId: ID of the debuggee whose breakpoint to get.
  2222  func (r *DebuggerDebuggeesBreakpointsService) Get(debuggeeId string, breakpointId string) *DebuggerDebuggeesBreakpointsGetCall {
  2223  	c := &DebuggerDebuggeesBreakpointsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2224  	c.debuggeeId = debuggeeId
  2225  	c.breakpointId = breakpointId
  2226  	return c
  2227  }
  2228  
  2229  // ClientVersion sets the optional parameter "clientVersion": Required.
  2230  // The client version making the call. Schema: `domain/type/version`
  2231  // (e.g., `google.com/intellij/v1`).
  2232  func (c *DebuggerDebuggeesBreakpointsGetCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsGetCall {
  2233  	c.urlParams_.Set("clientVersion", clientVersion)
  2234  	return c
  2235  }
  2236  
  2237  // Fields allows partial responses to be retrieved. See
  2238  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2239  // for more information.
  2240  func (c *DebuggerDebuggeesBreakpointsGetCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsGetCall {
  2241  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2242  	return c
  2243  }
  2244  
  2245  // IfNoneMatch sets the optional parameter which makes the operation
  2246  // fail if the object's ETag matches the given value. This is useful for
  2247  // getting updates only after the object has changed since the last
  2248  // request. Use googleapi.IsNotModified to check whether the response
  2249  // error from Do is the result of In-None-Match.
  2250  func (c *DebuggerDebuggeesBreakpointsGetCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesBreakpointsGetCall {
  2251  	c.ifNoneMatch_ = entityTag
  2252  	return c
  2253  }
  2254  
  2255  // Context sets the context to be used in this call's Do method. Any
  2256  // pending HTTP request will be aborted if the provided context is
  2257  // canceled.
  2258  func (c *DebuggerDebuggeesBreakpointsGetCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsGetCall {
  2259  	c.ctx_ = ctx
  2260  	return c
  2261  }
  2262  
  2263  // Header returns an http.Header that can be modified by the caller to
  2264  // add HTTP headers to the request.
  2265  func (c *DebuggerDebuggeesBreakpointsGetCall) Header() http.Header {
  2266  	if c.header_ == nil {
  2267  		c.header_ = make(http.Header)
  2268  	}
  2269  	return c.header_
  2270  }
  2271  
  2272  func (c *DebuggerDebuggeesBreakpointsGetCall) doRequest(alt string) (*http.Response, error) {
  2273  	reqHeaders := make(http.Header)
  2274  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  2275  	for k, v := range c.header_ {
  2276  		reqHeaders[k] = v
  2277  	}
  2278  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2279  	if c.ifNoneMatch_ != "" {
  2280  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2281  	}
  2282  	var body io.Reader = nil
  2283  	c.urlParams_.Set("alt", alt)
  2284  	c.urlParams_.Set("prettyPrint", "false")
  2285  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}")
  2286  	urls += "?" + c.urlParams_.Encode()
  2287  	req, err := http.NewRequest("GET", urls, body)
  2288  	if err != nil {
  2289  		return nil, err
  2290  	}
  2291  	req.Header = reqHeaders
  2292  	googleapi.Expand(req.URL, map[string]string{
  2293  		"debuggeeId":   c.debuggeeId,
  2294  		"breakpointId": c.breakpointId,
  2295  	})
  2296  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2297  }
  2298  
  2299  // Do executes the "clouddebugger.debugger.debuggees.breakpoints.get" call.
  2300  // Exactly one of *GetBreakpointResponse or error will be non-nil. Any
  2301  // non-2xx status code is an error. Response headers are in either
  2302  // *GetBreakpointResponse.ServerResponse.Header or (if a response was
  2303  // returned at all) in error.(*googleapi.Error).Header. Use
  2304  // googleapi.IsNotModified to check whether the returned error was
  2305  // because http.StatusNotModified was returned.
  2306  func (c *DebuggerDebuggeesBreakpointsGetCall) Do(opts ...googleapi.CallOption) (*GetBreakpointResponse, error) {
  2307  	gensupport.SetOptions(c.urlParams_, opts...)
  2308  	res, err := c.doRequest("json")
  2309  	if res != nil && res.StatusCode == http.StatusNotModified {
  2310  		if res.Body != nil {
  2311  			res.Body.Close()
  2312  		}
  2313  		return nil, gensupport.WrapError(&googleapi.Error{
  2314  			Code:   res.StatusCode,
  2315  			Header: res.Header,
  2316  		})
  2317  	}
  2318  	if err != nil {
  2319  		return nil, err
  2320  	}
  2321  	defer googleapi.CloseBody(res)
  2322  	if err := googleapi.CheckResponse(res); err != nil {
  2323  		return nil, gensupport.WrapError(err)
  2324  	}
  2325  	ret := &GetBreakpointResponse{
  2326  		ServerResponse: googleapi.ServerResponse{
  2327  			Header:         res.Header,
  2328  			HTTPStatusCode: res.StatusCode,
  2329  		},
  2330  	}
  2331  	target := &ret
  2332  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2333  		return nil, err
  2334  	}
  2335  	return ret, nil
  2336  	// {
  2337  	//   "description": "Gets breakpoint information.",
  2338  	//   "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}",
  2339  	//   "httpMethod": "GET",
  2340  	//   "id": "clouddebugger.debugger.debuggees.breakpoints.get",
  2341  	//   "parameterOrder": [
  2342  	//     "debuggeeId",
  2343  	//     "breakpointId"
  2344  	//   ],
  2345  	//   "parameters": {
  2346  	//     "breakpointId": {
  2347  	//       "description": "Required. ID of the breakpoint to get.",
  2348  	//       "location": "path",
  2349  	//       "required": true,
  2350  	//       "type": "string"
  2351  	//     },
  2352  	//     "clientVersion": {
  2353  	//       "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).",
  2354  	//       "location": "query",
  2355  	//       "type": "string"
  2356  	//     },
  2357  	//     "debuggeeId": {
  2358  	//       "description": "Required. ID of the debuggee whose breakpoint to get.",
  2359  	//       "location": "path",
  2360  	//       "required": true,
  2361  	//       "type": "string"
  2362  	//     }
  2363  	//   },
  2364  	//   "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}",
  2365  	//   "response": {
  2366  	//     "$ref": "GetBreakpointResponse"
  2367  	//   },
  2368  	//   "scopes": [
  2369  	//     "https://www.googleapis.com/auth/cloud-platform",
  2370  	//     "https://www.googleapis.com/auth/cloud_debugger"
  2371  	//   ]
  2372  	// }
  2373  
  2374  }
  2375  
  2376  // method id "clouddebugger.debugger.debuggees.breakpoints.list":
  2377  
  2378  type DebuggerDebuggeesBreakpointsListCall struct {
  2379  	s            *Service
  2380  	debuggeeId   string
  2381  	urlParams_   gensupport.URLParams
  2382  	ifNoneMatch_ string
  2383  	ctx_         context.Context
  2384  	header_      http.Header
  2385  }
  2386  
  2387  // List: Lists all breakpoints for the debuggee.
  2388  //
  2389  // - debuggeeId: ID of the debuggee whose breakpoints to list.
  2390  func (r *DebuggerDebuggeesBreakpointsService) List(debuggeeId string) *DebuggerDebuggeesBreakpointsListCall {
  2391  	c := &DebuggerDebuggeesBreakpointsListCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2392  	c.debuggeeId = debuggeeId
  2393  	return c
  2394  }
  2395  
  2396  // ActionValue sets the optional parameter "action.value": Only
  2397  // breakpoints with the specified action will pass the filter.
  2398  //
  2399  // Possible values:
  2400  //
  2401  //	"CAPTURE" - Capture stack frame and variables and update the
  2402  //
  2403  // breakpoint. The data is only captured once. After that the breakpoint
  2404  // is set in a final state.
  2405  //
  2406  //	"LOG" - Log each breakpoint hit. The breakpoint remains active
  2407  //
  2408  // until deleted or expired.
  2409  func (c *DebuggerDebuggeesBreakpointsListCall) ActionValue(actionValue string) *DebuggerDebuggeesBreakpointsListCall {
  2410  	c.urlParams_.Set("action.value", actionValue)
  2411  	return c
  2412  }
  2413  
  2414  // ClientVersion sets the optional parameter "clientVersion": Required.
  2415  // The client version making the call. Schema: `domain/type/version`
  2416  // (e.g., `google.com/intellij/v1`).
  2417  func (c *DebuggerDebuggeesBreakpointsListCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsListCall {
  2418  	c.urlParams_.Set("clientVersion", clientVersion)
  2419  	return c
  2420  }
  2421  
  2422  // IncludeAllUsers sets the optional parameter "includeAllUsers": When
  2423  // set to `true`, the response includes the list of breakpoints set by
  2424  // any user. Otherwise, it includes only breakpoints set by the caller.
  2425  func (c *DebuggerDebuggeesBreakpointsListCall) IncludeAllUsers(includeAllUsers bool) *DebuggerDebuggeesBreakpointsListCall {
  2426  	c.urlParams_.Set("includeAllUsers", fmt.Sprint(includeAllUsers))
  2427  	return c
  2428  }
  2429  
  2430  // IncludeInactive sets the optional parameter "includeInactive": When
  2431  // set to `true`, the response includes active and inactive breakpoints.
  2432  // Otherwise, it includes only active breakpoints.
  2433  func (c *DebuggerDebuggeesBreakpointsListCall) IncludeInactive(includeInactive bool) *DebuggerDebuggeesBreakpointsListCall {
  2434  	c.urlParams_.Set("includeInactive", fmt.Sprint(includeInactive))
  2435  	return c
  2436  }
  2437  
  2438  // StripResults sets the optional parameter "stripResults": This field
  2439  // is deprecated. The following fields are always stripped out of the
  2440  // result: `stack_frames`, `evaluated_expressions` and `variable_table`.
  2441  func (c *DebuggerDebuggeesBreakpointsListCall) StripResults(stripResults bool) *DebuggerDebuggeesBreakpointsListCall {
  2442  	c.urlParams_.Set("stripResults", fmt.Sprint(stripResults))
  2443  	return c
  2444  }
  2445  
  2446  // WaitToken sets the optional parameter "waitToken": A wait token that,
  2447  // if specified, blocks the call until the breakpoints list has changed,
  2448  // or a server selected timeout has expired. The value should be set
  2449  // from the last response. The error code `google.rpc.Code.ABORTED`
  2450  // (RPC) is returned on wait timeout, which should be called again with
  2451  // the same `wait_token`.
  2452  func (c *DebuggerDebuggeesBreakpointsListCall) WaitToken(waitToken string) *DebuggerDebuggeesBreakpointsListCall {
  2453  	c.urlParams_.Set("waitToken", waitToken)
  2454  	return c
  2455  }
  2456  
  2457  // Fields allows partial responses to be retrieved. See
  2458  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2459  // for more information.
  2460  func (c *DebuggerDebuggeesBreakpointsListCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsListCall {
  2461  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2462  	return c
  2463  }
  2464  
  2465  // IfNoneMatch sets the optional parameter which makes the operation
  2466  // fail if the object's ETag matches the given value. This is useful for
  2467  // getting updates only after the object has changed since the last
  2468  // request. Use googleapi.IsNotModified to check whether the response
  2469  // error from Do is the result of In-None-Match.
  2470  func (c *DebuggerDebuggeesBreakpointsListCall) IfNoneMatch(entityTag string) *DebuggerDebuggeesBreakpointsListCall {
  2471  	c.ifNoneMatch_ = entityTag
  2472  	return c
  2473  }
  2474  
  2475  // Context sets the context to be used in this call's Do method. Any
  2476  // pending HTTP request will be aborted if the provided context is
  2477  // canceled.
  2478  func (c *DebuggerDebuggeesBreakpointsListCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsListCall {
  2479  	c.ctx_ = ctx
  2480  	return c
  2481  }
  2482  
  2483  // Header returns an http.Header that can be modified by the caller to
  2484  // add HTTP headers to the request.
  2485  func (c *DebuggerDebuggeesBreakpointsListCall) Header() http.Header {
  2486  	if c.header_ == nil {
  2487  		c.header_ = make(http.Header)
  2488  	}
  2489  	return c.header_
  2490  }
  2491  
  2492  func (c *DebuggerDebuggeesBreakpointsListCall) doRequest(alt string) (*http.Response, error) {
  2493  	reqHeaders := make(http.Header)
  2494  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  2495  	for k, v := range c.header_ {
  2496  		reqHeaders[k] = v
  2497  	}
  2498  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2499  	if c.ifNoneMatch_ != "" {
  2500  		reqHeaders.Set("If-None-Match", c.ifNoneMatch_)
  2501  	}
  2502  	var body io.Reader = nil
  2503  	c.urlParams_.Set("alt", alt)
  2504  	c.urlParams_.Set("prettyPrint", "false")
  2505  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints")
  2506  	urls += "?" + c.urlParams_.Encode()
  2507  	req, err := http.NewRequest("GET", urls, body)
  2508  	if err != nil {
  2509  		return nil, err
  2510  	}
  2511  	req.Header = reqHeaders
  2512  	googleapi.Expand(req.URL, map[string]string{
  2513  		"debuggeeId": c.debuggeeId,
  2514  	})
  2515  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2516  }
  2517  
  2518  // Do executes the "clouddebugger.debugger.debuggees.breakpoints.list" call.
  2519  // Exactly one of *ListBreakpointsResponse or error will be non-nil. Any
  2520  // non-2xx status code is an error. Response headers are in either
  2521  // *ListBreakpointsResponse.ServerResponse.Header or (if a response was
  2522  // returned at all) in error.(*googleapi.Error).Header. Use
  2523  // googleapi.IsNotModified to check whether the returned error was
  2524  // because http.StatusNotModified was returned.
  2525  func (c *DebuggerDebuggeesBreakpointsListCall) Do(opts ...googleapi.CallOption) (*ListBreakpointsResponse, error) {
  2526  	gensupport.SetOptions(c.urlParams_, opts...)
  2527  	res, err := c.doRequest("json")
  2528  	if res != nil && res.StatusCode == http.StatusNotModified {
  2529  		if res.Body != nil {
  2530  			res.Body.Close()
  2531  		}
  2532  		return nil, gensupport.WrapError(&googleapi.Error{
  2533  			Code:   res.StatusCode,
  2534  			Header: res.Header,
  2535  		})
  2536  	}
  2537  	if err != nil {
  2538  		return nil, err
  2539  	}
  2540  	defer googleapi.CloseBody(res)
  2541  	if err := googleapi.CheckResponse(res); err != nil {
  2542  		return nil, gensupport.WrapError(err)
  2543  	}
  2544  	ret := &ListBreakpointsResponse{
  2545  		ServerResponse: googleapi.ServerResponse{
  2546  			Header:         res.Header,
  2547  			HTTPStatusCode: res.StatusCode,
  2548  		},
  2549  	}
  2550  	target := &ret
  2551  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2552  		return nil, err
  2553  	}
  2554  	return ret, nil
  2555  	// {
  2556  	//   "description": "Lists all breakpoints for the debuggee.",
  2557  	//   "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints",
  2558  	//   "httpMethod": "GET",
  2559  	//   "id": "clouddebugger.debugger.debuggees.breakpoints.list",
  2560  	//   "parameterOrder": [
  2561  	//     "debuggeeId"
  2562  	//   ],
  2563  	//   "parameters": {
  2564  	//     "action.value": {
  2565  	//       "description": "Only breakpoints with the specified action will pass the filter.",
  2566  	//       "enum": [
  2567  	//         "CAPTURE",
  2568  	//         "LOG"
  2569  	//       ],
  2570  	//       "enumDescriptions": [
  2571  	//         "Capture stack frame and variables and update the breakpoint. The data is only captured once. After that the breakpoint is set in a final state.",
  2572  	//         "Log each breakpoint hit. The breakpoint remains active until deleted or expired."
  2573  	//       ],
  2574  	//       "location": "query",
  2575  	//       "type": "string"
  2576  	//     },
  2577  	//     "clientVersion": {
  2578  	//       "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).",
  2579  	//       "location": "query",
  2580  	//       "type": "string"
  2581  	//     },
  2582  	//     "debuggeeId": {
  2583  	//       "description": "Required. ID of the debuggee whose breakpoints to list.",
  2584  	//       "location": "path",
  2585  	//       "required": true,
  2586  	//       "type": "string"
  2587  	//     },
  2588  	//     "includeAllUsers": {
  2589  	//       "description": "When set to `true`, the response includes the list of breakpoints set by any user. Otherwise, it includes only breakpoints set by the caller.",
  2590  	//       "location": "query",
  2591  	//       "type": "boolean"
  2592  	//     },
  2593  	//     "includeInactive": {
  2594  	//       "description": "When set to `true`, the response includes active and inactive breakpoints. Otherwise, it includes only active breakpoints.",
  2595  	//       "location": "query",
  2596  	//       "type": "boolean"
  2597  	//     },
  2598  	//     "stripResults": {
  2599  	//       "deprecated": true,
  2600  	//       "description": "This field is deprecated. The following fields are always stripped out of the result: `stack_frames`, `evaluated_expressions` and `variable_table`.",
  2601  	//       "location": "query",
  2602  	//       "type": "boolean"
  2603  	//     },
  2604  	//     "waitToken": {
  2605  	//       "description": "A wait token that, if specified, blocks the call until the breakpoints list has changed, or a server selected timeout has expired. The value should be set from the last response. The error code `google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which should be called again with the same `wait_token`.",
  2606  	//       "location": "query",
  2607  	//       "type": "string"
  2608  	//     }
  2609  	//   },
  2610  	//   "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints",
  2611  	//   "response": {
  2612  	//     "$ref": "ListBreakpointsResponse"
  2613  	//   },
  2614  	//   "scopes": [
  2615  	//     "https://www.googleapis.com/auth/cloud-platform",
  2616  	//     "https://www.googleapis.com/auth/cloud_debugger"
  2617  	//   ]
  2618  	// }
  2619  
  2620  }
  2621  
  2622  // method id "clouddebugger.debugger.debuggees.breakpoints.set":
  2623  
  2624  type DebuggerDebuggeesBreakpointsSetCall struct {
  2625  	s          *Service
  2626  	debuggeeId string
  2627  	breakpoint *Breakpoint
  2628  	urlParams_ gensupport.URLParams
  2629  	ctx_       context.Context
  2630  	header_    http.Header
  2631  }
  2632  
  2633  // Set: Sets the breakpoint to the debuggee.
  2634  //
  2635  // - debuggeeId: ID of the debuggee where the breakpoint is to be set.
  2636  func (r *DebuggerDebuggeesBreakpointsService) Set(debuggeeId string, breakpoint *Breakpoint) *DebuggerDebuggeesBreakpointsSetCall {
  2637  	c := &DebuggerDebuggeesBreakpointsSetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
  2638  	c.debuggeeId = debuggeeId
  2639  	c.breakpoint = breakpoint
  2640  	return c
  2641  }
  2642  
  2643  // CanaryOption sets the optional parameter "canaryOption": The canary
  2644  // option set by the user upon setting breakpoint.
  2645  //
  2646  // Possible values:
  2647  //
  2648  //	"CANARY_OPTION_UNSPECIFIED" - Depends on the canary_mode of the
  2649  //
  2650  // debuggee.
  2651  //
  2652  //	"CANARY_OPTION_TRY_ENABLE" - Enable the canary for this breakpoint
  2653  //
  2654  // if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED
  2655  // or CANARY_MODE_ALWAYS_DISABLED.
  2656  //
  2657  //	"CANARY_OPTION_TRY_DISABLE" - Disable the canary for this
  2658  //
  2659  // breakpoint if the canary_mode of the debuggee is not
  2660  // CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED.
  2661  func (c *DebuggerDebuggeesBreakpointsSetCall) CanaryOption(canaryOption string) *DebuggerDebuggeesBreakpointsSetCall {
  2662  	c.urlParams_.Set("canaryOption", canaryOption)
  2663  	return c
  2664  }
  2665  
  2666  // ClientVersion sets the optional parameter "clientVersion": Required.
  2667  // The client version making the call. Schema: `domain/type/version`
  2668  // (e.g., `google.com/intellij/v1`).
  2669  func (c *DebuggerDebuggeesBreakpointsSetCall) ClientVersion(clientVersion string) *DebuggerDebuggeesBreakpointsSetCall {
  2670  	c.urlParams_.Set("clientVersion", clientVersion)
  2671  	return c
  2672  }
  2673  
  2674  // Fields allows partial responses to be retrieved. See
  2675  // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse
  2676  // for more information.
  2677  func (c *DebuggerDebuggeesBreakpointsSetCall) Fields(s ...googleapi.Field) *DebuggerDebuggeesBreakpointsSetCall {
  2678  	c.urlParams_.Set("fields", googleapi.CombineFields(s))
  2679  	return c
  2680  }
  2681  
  2682  // Context sets the context to be used in this call's Do method. Any
  2683  // pending HTTP request will be aborted if the provided context is
  2684  // canceled.
  2685  func (c *DebuggerDebuggeesBreakpointsSetCall) Context(ctx context.Context) *DebuggerDebuggeesBreakpointsSetCall {
  2686  	c.ctx_ = ctx
  2687  	return c
  2688  }
  2689  
  2690  // Header returns an http.Header that can be modified by the caller to
  2691  // add HTTP headers to the request.
  2692  func (c *DebuggerDebuggeesBreakpointsSetCall) Header() http.Header {
  2693  	if c.header_ == nil {
  2694  		c.header_ = make(http.Header)
  2695  	}
  2696  	return c.header_
  2697  }
  2698  
  2699  func (c *DebuggerDebuggeesBreakpointsSetCall) doRequest(alt string) (*http.Response, error) {
  2700  	reqHeaders := make(http.Header)
  2701  	reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version)
  2702  	for k, v := range c.header_ {
  2703  		reqHeaders[k] = v
  2704  	}
  2705  	reqHeaders.Set("User-Agent", c.s.userAgent())
  2706  	var body io.Reader = nil
  2707  	body, err := googleapi.WithoutDataWrapper.JSONReader(c.breakpoint)
  2708  	if err != nil {
  2709  		return nil, err
  2710  	}
  2711  	reqHeaders.Set("Content-Type", "application/json")
  2712  	c.urlParams_.Set("alt", alt)
  2713  	c.urlParams_.Set("prettyPrint", "false")
  2714  	urls := googleapi.ResolveRelative(c.s.BasePath, "v2/debugger/debuggees/{debuggeeId}/breakpoints/set")
  2715  	urls += "?" + c.urlParams_.Encode()
  2716  	req, err := http.NewRequest("POST", urls, body)
  2717  	if err != nil {
  2718  		return nil, err
  2719  	}
  2720  	req.Header = reqHeaders
  2721  	googleapi.Expand(req.URL, map[string]string{
  2722  		"debuggeeId": c.debuggeeId,
  2723  	})
  2724  	return gensupport.SendRequest(c.ctx_, c.s.client, req)
  2725  }
  2726  
  2727  // Do executes the "clouddebugger.debugger.debuggees.breakpoints.set" call.
  2728  // Exactly one of *SetBreakpointResponse or error will be non-nil. Any
  2729  // non-2xx status code is an error. Response headers are in either
  2730  // *SetBreakpointResponse.ServerResponse.Header or (if a response was
  2731  // returned at all) in error.(*googleapi.Error).Header. Use
  2732  // googleapi.IsNotModified to check whether the returned error was
  2733  // because http.StatusNotModified was returned.
  2734  func (c *DebuggerDebuggeesBreakpointsSetCall) Do(opts ...googleapi.CallOption) (*SetBreakpointResponse, error) {
  2735  	gensupport.SetOptions(c.urlParams_, opts...)
  2736  	res, err := c.doRequest("json")
  2737  	if res != nil && res.StatusCode == http.StatusNotModified {
  2738  		if res.Body != nil {
  2739  			res.Body.Close()
  2740  		}
  2741  		return nil, gensupport.WrapError(&googleapi.Error{
  2742  			Code:   res.StatusCode,
  2743  			Header: res.Header,
  2744  		})
  2745  	}
  2746  	if err != nil {
  2747  		return nil, err
  2748  	}
  2749  	defer googleapi.CloseBody(res)
  2750  	if err := googleapi.CheckResponse(res); err != nil {
  2751  		return nil, gensupport.WrapError(err)
  2752  	}
  2753  	ret := &SetBreakpointResponse{
  2754  		ServerResponse: googleapi.ServerResponse{
  2755  			Header:         res.Header,
  2756  			HTTPStatusCode: res.StatusCode,
  2757  		},
  2758  	}
  2759  	target := &ret
  2760  	if err := gensupport.DecodeResponse(target, res); err != nil {
  2761  		return nil, err
  2762  	}
  2763  	return ret, nil
  2764  	// {
  2765  	//   "description": "Sets the breakpoint to the debuggee.",
  2766  	//   "flatPath": "v2/debugger/debuggees/{debuggeeId}/breakpoints/set",
  2767  	//   "httpMethod": "POST",
  2768  	//   "id": "clouddebugger.debugger.debuggees.breakpoints.set",
  2769  	//   "parameterOrder": [
  2770  	//     "debuggeeId"
  2771  	//   ],
  2772  	//   "parameters": {
  2773  	//     "canaryOption": {
  2774  	//       "description": "The canary option set by the user upon setting breakpoint.",
  2775  	//       "enum": [
  2776  	//         "CANARY_OPTION_UNSPECIFIED",
  2777  	//         "CANARY_OPTION_TRY_ENABLE",
  2778  	//         "CANARY_OPTION_TRY_DISABLE"
  2779  	//       ],
  2780  	//       "enumDescriptions": [
  2781  	//         "Depends on the canary_mode of the debuggee.",
  2782  	//         "Enable the canary for this breakpoint if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED.",
  2783  	//         "Disable the canary for this breakpoint if the canary_mode of the debuggee is not CANARY_MODE_ALWAYS_ENABLED or CANARY_MODE_ALWAYS_DISABLED."
  2784  	//       ],
  2785  	//       "location": "query",
  2786  	//       "type": "string"
  2787  	//     },
  2788  	//     "clientVersion": {
  2789  	//       "description": "Required. The client version making the call. Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).",
  2790  	//       "location": "query",
  2791  	//       "type": "string"
  2792  	//     },
  2793  	//     "debuggeeId": {
  2794  	//       "description": "Required. ID of the debuggee where the breakpoint is to be set.",
  2795  	//       "location": "path",
  2796  	//       "required": true,
  2797  	//       "type": "string"
  2798  	//     }
  2799  	//   },
  2800  	//   "path": "v2/debugger/debuggees/{debuggeeId}/breakpoints/set",
  2801  	//   "request": {
  2802  	//     "$ref": "Breakpoint"
  2803  	//   },
  2804  	//   "response": {
  2805  	//     "$ref": "SetBreakpointResponse"
  2806  	//   },
  2807  	//   "scopes": [
  2808  	//     "https://www.googleapis.com/auth/cloud-platform",
  2809  	//     "https://www.googleapis.com/auth/cloud_debugger"
  2810  	//   ]
  2811  	// }
  2812  
  2813  }
  2814  

View as plain text