<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="clouddebugger_v2.html">Cloud Debugger API</a> . <a href="clouddebugger_v2.debugger.html">debugger</a> . <a href="clouddebugger_v2.debugger.debuggees.html">debuggees</a> . <a href="clouddebugger_v2.debugger.debuggees.breakpoints.html">breakpoints</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="#delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes the breakpoint from the debuggee.</p>
<p class="toc_element">
  <code><a href="#get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>
<p class="firstline">Gets breakpoint information.</p>
<p class="toc_element">
  <code><a href="#list">list(debuggeeId, waitToken=None, clientVersion=None, action_value=None, includeAllUsers=None, includeInactive=None, stripResults=None, x__xgafv=None)</a></code></p>
<p class="firstline">Lists all breakpoints for the debuggee.</p>
<p class="toc_element">
  <code><a href="#set">set(debuggeeId, body=None, canaryOption=None, clientVersion=None, x__xgafv=None)</a></code></p>
<p class="firstline">Sets the breakpoint to the debuggee.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>
  <pre>Deletes the breakpoint from the debuggee.

Args:
  debuggeeId: string, Required. ID of the debuggee whose breakpoint to delete. (required)
  breakpointId: string, Required. ID of the breakpoint to delete. (required)
  clientVersion: string, Required. The client version making the call.
Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # A generic empty message that you can re-use to avoid defining duplicated
      # empty messages in your APIs. A typical example is to use it as the request
      # or the response type of an API method. For instance:
      #
      #     service Foo {
      #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
      #     }
      #
      # The JSON representation for `Empty` is empty JSON object `{}`.
  }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>
  <pre>Gets breakpoint information.

Args:
  debuggeeId: string, Required. ID of the debuggee whose breakpoint to get. (required)
  breakpointId: string, Required. ID of the breakpoint to get. (required)
  clientVersion: string, Required. The client version making the call.
Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response for getting breakpoint information.
    &quot;breakpoint&quot;: { # ------------------------------------------------------------------------------ # Complete breakpoint state.
        # The fields `id` and `location` are guaranteed to be set.
        # ## Breakpoint (the resource)
        #
        # Represents the breakpoint specification, status and results.
      &quot;expressions&quot;: [ # List of read-only expressions to evaluate at the breakpoint location.
          # The expressions are composed using expressions in the programming language
          # at the source location. If the breakpoint action is `LOG`, the evaluated
          # expressions are included in log statements.
        &quot;A String&quot;,
      ],
      &quot;evaluatedExpressions&quot;: [ # Values of evaluated expressions at breakpoint time.
          # The evaluated expressions appear in exactly the same order they
          # are listed in the `expressions` field.
          # The `name` field holds the original expression text, the `value` or
          # `members` field holds the result of the evaluated expression.
          # If the expression cannot be evaluated, the `status` inside the `Variable`
          # will indicate an error and contain the error text.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
      &quot;isFinalState&quot;: True or False, # When true, indicates that this is a final result and the
          # breakpoint state will not change from here on.
      &quot;stackFrames&quot;: [ # The stack at breakpoint time, where stack_frames[0] represents the most
          # recently entered function.
        { # Represents a stack frame context.
          &quot;locals&quot;: [ # Set of local variables at the stack frame location.
              # Note that this might not be populated for all stack frames.
            { # Represents a variable or an argument possibly of a compound object type.
                # Note how the following variables are represented:
                #
                # 1) A simple variable:
                #
                #     int x = 5
                #
                #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                #
                # 2) A compound object:
                #
                #     struct T {
                #         int m1;
                #         int m2;
                #     };
                #     T x = { 3, 7 };
                #
                #     {  // Captured variable
                #         name: &quot;x&quot;,
                #         type: &quot;T&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 3) A pointer where the pointee was captured:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00500500&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 4) A pointer where the pointee was not captured:
                #
                #     T* p = new T;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00400400&quot;
                #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                #     }
                #
                # The status should describe the reason for the missing value,
                # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                #
                # Note that a null pointer should not have members.
                #
                # 5) An unnamed value:
                #
                #     int* p = new int(7);
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int*&quot;,
                #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                #
                # 6) An unnamed pointer where the pointee was not captured:
                #
                #     int* p = new int(7);
                #     int** pp = &amp;p;
                #
                #     {  // Captured variable
                #         name: &quot;pp&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int**&quot;,
                #         members {
                #             value: &quot;0x00400400&quot;,
                #             type: &quot;int*&quot;
                #             status {
                #                 is_error: true,
                #                 description: { format: &quot;unavailable&quot; } }
                #             }
                #         }
                #     }
                #
                # To optimize computation, memory and network traffic, variables that
                # repeat in the output multiple times can be stored once in a shared
                # variable table and be referenced using the `var_table_index` field.  The
                # variables stored in the shared table are nameless and are essentially
                # a partition of the complete variable. To reconstruct the complete
                # variable, merge the referencing variable with the referenced variable.
                #
                # When using the shared variable table, the following variables:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #     T&amp; r = x;
                #
                #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                #
                #     {  // Shared variable table entry #3:
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # Note that the pointer address is stored with the referencing variable
                # and not with the referenced variable. This allows the referenced variable
                # to be shared between pointers and references.
                #
                # The type field is optional. The debugger agent may or may not support it.
              &quot;members&quot;: [ # Members contained or pointed to by the variable.
                # Object with schema name: Variable
              ],
              &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                  # unset. A status of a single variable only applies to that variable or
                  # expression. The rest of breakpoint data still remains valid. Variables
                  # might be reported in error state even when breakpoint is not in final
                  # state.
                  #
                  # The message may refer to variable name with `refers_to` set to
                  # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                  # In either case variable value and members will be unset.
                  #
                  # Example of error message applied to name: `Invalid expression syntax`.
                  #
                  # Example of information message applied to value: `Not captured`.
                  #
                  # Examples of error message applied to value:
                  #
                  # *   `Malformed string`,
                  # *   `Field f not found in class C`
                  # *   `Null pointer dereference`
                  # The message can indicate an error or informational status, and refer to
                  # specific parts of the containing object.
                  # For example, the `Breakpoint.status` field can indicate an error referring
                  # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                  &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                      # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                      # character.
                      #
                      # Examples:
                      #
                      # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                      #     is loaded.  Again, $0 is very important.`
                      # *   `Please pay $$10 to use $0 instead of $1.`
                  &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                    &quot;A String&quot;,
                  ],
                },
                &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
              },
              &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
              &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                  # `var_table_index`, `type` goes next to `value`. The interpretation of
                  # a type is agent specific. It is recommended to include the dynamic type
                  # rather than a static type of an object.
              &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
              &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                  # one variable can reference the same variable in the table. The
                  # `var_table_index` field is an index into `variable_table` in Breakpoint.
            },
          ],
          &quot;location&quot;: { # Represents a location in the source code. # Source location of the call site.
            &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
            &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
                # Agents that do not support setting breakpoints on specific columns ignore
                # this field.
            &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
          },
          &quot;function&quot;: &quot;A String&quot;, # Demangled function name at the call site.
          &quot;arguments&quot;: [ # Set of arguments passed to this function.
              # Note that this might not be populated for all stack frames.
            { # Represents a variable or an argument possibly of a compound object type.
                # Note how the following variables are represented:
                #
                # 1) A simple variable:
                #
                #     int x = 5
                #
                #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                #
                # 2) A compound object:
                #
                #     struct T {
                #         int m1;
                #         int m2;
                #     };
                #     T x = { 3, 7 };
                #
                #     {  // Captured variable
                #         name: &quot;x&quot;,
                #         type: &quot;T&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 3) A pointer where the pointee was captured:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00500500&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 4) A pointer where the pointee was not captured:
                #
                #     T* p = new T;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00400400&quot;
                #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                #     }
                #
                # The status should describe the reason for the missing value,
                # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                #
                # Note that a null pointer should not have members.
                #
                # 5) An unnamed value:
                #
                #     int* p = new int(7);
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int*&quot;,
                #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                #
                # 6) An unnamed pointer where the pointee was not captured:
                #
                #     int* p = new int(7);
                #     int** pp = &amp;p;
                #
                #     {  // Captured variable
                #         name: &quot;pp&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int**&quot;,
                #         members {
                #             value: &quot;0x00400400&quot;,
                #             type: &quot;int*&quot;
                #             status {
                #                 is_error: true,
                #                 description: { format: &quot;unavailable&quot; } }
                #             }
                #         }
                #     }
                #
                # To optimize computation, memory and network traffic, variables that
                # repeat in the output multiple times can be stored once in a shared
                # variable table and be referenced using the `var_table_index` field.  The
                # variables stored in the shared table are nameless and are essentially
                # a partition of the complete variable. To reconstruct the complete
                # variable, merge the referencing variable with the referenced variable.
                #
                # When using the shared variable table, the following variables:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #     T&amp; r = x;
                #
                #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                #
                #     {  // Shared variable table entry #3:
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # Note that the pointer address is stored with the referencing variable
                # and not with the referenced variable. This allows the referenced variable
                # to be shared between pointers and references.
                #
                # The type field is optional. The debugger agent may or may not support it.
              &quot;members&quot;: [ # Members contained or pointed to by the variable.
                # Object with schema name: Variable
              ],
              &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                  # unset. A status of a single variable only applies to that variable or
                  # expression. The rest of breakpoint data still remains valid. Variables
                  # might be reported in error state even when breakpoint is not in final
                  # state.
                  #
                  # The message may refer to variable name with `refers_to` set to
                  # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                  # In either case variable value and members will be unset.
                  #
                  # Example of error message applied to name: `Invalid expression syntax`.
                  #
                  # Example of information message applied to value: `Not captured`.
                  #
                  # Examples of error message applied to value:
                  #
                  # *   `Malformed string`,
                  # *   `Field f not found in class C`
                  # *   `Null pointer dereference`
                  # The message can indicate an error or informational status, and refer to
                  # specific parts of the containing object.
                  # For example, the `Breakpoint.status` field can indicate an error referring
                  # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                  &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                      # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                      # character.
                      #
                      # Examples:
                      #
                      # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                      #     is loaded.  Again, $0 is very important.`
                      # *   `Please pay $$10 to use $0 instead of $1.`
                  &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                    &quot;A String&quot;,
                  ],
                },
                &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
              },
              &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
              &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                  # `var_table_index`, `type` goes next to `value`. The interpretation of
                  # a type is agent specific. It is recommended to include the dynamic type
                  # rather than a static type of an object.
              &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
              &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                  # one variable can reference the same variable in the table. The
                  # `var_table_index` field is an index into `variable_table` in Breakpoint.
            },
          ],
        },
      ],
      &quot;condition&quot;: &quot;A String&quot;, # Condition that triggers the breakpoint.
          # The condition is a compound boolean expression composed using expressions
          # in a programming language at the source location.
      &quot;canaryExpireTime&quot;: &quot;A String&quot;, # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
          # is meaningless when the breakpoint is not in CANARY_ACTIVE state.
      &quot;status&quot;: { # Represents a contextual status message. # Breakpoint status.
          #
          # The status includes an error flag and a human readable message.
          # This field is usually unset. The message can be either
          # informational or an error message. Regardless, clients should always
          # display the text message back to the user.
          #
          # Error status indicates complete failure of the breakpoint.
          #
          # Example (non-final state): `Still loading symbols...`
          #
          # Examples (final state):
          #
          # *   `Invalid line number` referring to location
          # *   `Field f not found in class C` referring to condition
          # The message can indicate an error or informational status, and refer to
          # specific parts of the containing object.
          # For example, the `Breakpoint.status` field can indicate an error referring
          # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
        &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
        &quot;description&quot;: { # Represents a message with parameters. # Status message text.
          &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
              # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
              # character.
              #
              # Examples:
              #
              # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
              #     is loaded.  Again, $0 is very important.`
              # *   `Please pay $$10 to use $0 instead of $1.`
          &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
            &quot;A String&quot;,
          ],
        },
        &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
      },
      &quot;state&quot;: &quot;A String&quot;, # The current state of the breakpoint.
      &quot;userEmail&quot;: &quot;A String&quot;, # E-mail address of the user that created this breakpoint
      &quot;action&quot;: &quot;A String&quot;, # Action that the agent should perform when the code at the
          # breakpoint location is hit.
      &quot;logLevel&quot;: &quot;A String&quot;, # Indicates the severity of the log. Only relevant when action is `LOG`.
      &quot;id&quot;: &quot;A String&quot;, # Breakpoint identifier, unique in the scope of the debuggee.
      &quot;location&quot;: { # Represents a location in the source code. # Breakpoint source location.
        &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
        &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
            # Agents that do not support setting breakpoints on specific columns ignore
            # this field.
        &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
      },
      &quot;finalTime&quot;: &quot;A String&quot;, # Time this breakpoint was finalized as seen by the server in seconds
          # resolution.
      &quot;variableTable&quot;: [ # The `variable_table` exists to aid with computation, memory and network
          # traffic optimization.  It enables storing a variable once and reference
          # it from multiple variables, including variables stored in the
          # `variable_table` itself.
          # For example, the same `this` object, which may appear at many levels of
          # the stack, can have all of its data stored once in this table.  The
          # stack frame variables then would hold only a reference to it.
          #
          # The variable `var_table_index` field is an index into this repeated field.
          # The stored objects are nameless and get their name from the referencing
          # variable. The effective variable is a merge of the referencing variable
          # and the referenced variable.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
      &quot;createTime&quot;: &quot;A String&quot;, # Time this breakpoint was created by the server in seconds resolution.
      &quot;logMessageFormat&quot;: &quot;A String&quot;, # Only relevant when action is `LOG`. Defines the message to log when
          # the breakpoint hits. The message may include parameter placeholders `$0`,
          # `$1`, etc. These placeholders are replaced with the evaluated value
          # of the appropriate expression. Expressions not referenced in
          # `log_message_format` are not logged.
          #
          # Example: `Message received, id = $0, count = $1` with
          # `expressions` = `[ message.id, message.count ]`.
      &quot;labels&quot;: { # A set of custom breakpoint properties, populated by the agent, to be
          # displayed to the user.
        &quot;a_key&quot;: &quot;A String&quot;,
      },
    },
  }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(debuggeeId, waitToken=None, clientVersion=None, action_value=None, includeAllUsers=None, includeInactive=None, stripResults=None, x__xgafv=None)</code>
  <pre>Lists all breakpoints for the debuggee.

Args:
  debuggeeId: string, Required. ID of the debuggee whose breakpoints to list. (required)
  waitToken: string, 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`.
  clientVersion: string, Required. The client version making the call.
Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).
  action_value: string, Only breakpoints with the specified action will pass the filter.
  includeAllUsers: boolean, When set to `true`, the response includes the list of breakpoints set by
any user. Otherwise, it includes only breakpoints set by the caller.
  includeInactive: boolean, When set to `true`, the response includes active and inactive
breakpoints. Otherwise, it includes only active breakpoints.
  stripResults: boolean, This field is deprecated. The following fields are always stripped out of
the result: `stack_frames`, `evaluated_expressions` and `variable_table`.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response for listing breakpoints.
    &quot;breakpoints&quot;: [ # List of breakpoints matching the request.
        # The fields `id` and `location` are guaranteed to be set on each breakpoint.
        # The fields: `stack_frames`, `evaluated_expressions` and `variable_table`
        # are cleared on each breakpoint regardless of its status.
      { # ------------------------------------------------------------------------------
          # ## Breakpoint (the resource)
          #
          # Represents the breakpoint specification, status and results.
        &quot;expressions&quot;: [ # List of read-only expressions to evaluate at the breakpoint location.
            # The expressions are composed using expressions in the programming language
            # at the source location. If the breakpoint action is `LOG`, the evaluated
            # expressions are included in log statements.
          &quot;A String&quot;,
        ],
        &quot;evaluatedExpressions&quot;: [ # Values of evaluated expressions at breakpoint time.
            # The evaluated expressions appear in exactly the same order they
            # are listed in the `expressions` field.
            # The `name` field holds the original expression text, the `value` or
            # `members` field holds the result of the evaluated expression.
            # If the expression cannot be evaluated, the `status` inside the `Variable`
            # will indicate an error and contain the error text.
          { # Represents a variable or an argument possibly of a compound object type.
              # Note how the following variables are represented:
              #
              # 1) A simple variable:
              #
              #     int x = 5
              #
              #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
              #
              # 2) A compound object:
              #
              #     struct T {
              #         int m1;
              #         int m2;
              #     };
              #     T x = { 3, 7 };
              #
              #     {  // Captured variable
              #         name: &quot;x&quot;,
              #         type: &quot;T&quot;,
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # 3) A pointer where the pointee was captured:
              #
              #     T x = { 3, 7 };
              #     T* p = &amp;x;
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         type: &quot;T*&quot;,
              #         value: &quot;0x00500500&quot;,
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # 4) A pointer where the pointee was not captured:
              #
              #     T* p = new T;
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         type: &quot;T*&quot;,
              #         value: &quot;0x00400400&quot;
              #         status { is_error: true, description { format: &quot;unavailable&quot; } }
              #     }
              #
              # The status should describe the reason for the missing value,
              # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
              #
              # Note that a null pointer should not have members.
              #
              # 5) An unnamed value:
              #
              #     int* p = new int(7);
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         value: &quot;0x00500500&quot;,
              #         type: &quot;int*&quot;,
              #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
              #
              # 6) An unnamed pointer where the pointee was not captured:
              #
              #     int* p = new int(7);
              #     int** pp = &amp;p;
              #
              #     {  // Captured variable
              #         name: &quot;pp&quot;,
              #         value: &quot;0x00500500&quot;,
              #         type: &quot;int**&quot;,
              #         members {
              #             value: &quot;0x00400400&quot;,
              #             type: &quot;int*&quot;
              #             status {
              #                 is_error: true,
              #                 description: { format: &quot;unavailable&quot; } }
              #             }
              #         }
              #     }
              #
              # To optimize computation, memory and network traffic, variables that
              # repeat in the output multiple times can be stored once in a shared
              # variable table and be referenced using the `var_table_index` field.  The
              # variables stored in the shared table are nameless and are essentially
              # a partition of the complete variable. To reconstruct the complete
              # variable, merge the referencing variable with the referenced variable.
              #
              # When using the shared variable table, the following variables:
              #
              #     T x = { 3, 7 };
              #     T* p = &amp;x;
              #     T&amp; r = x;
              #
              #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
              #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
              #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
              #
              #     {  // Shared variable table entry #3:
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # Note that the pointer address is stored with the referencing variable
              # and not with the referenced variable. This allows the referenced variable
              # to be shared between pointers and references.
              #
              # The type field is optional. The debugger agent may or may not support it.
            &quot;members&quot;: [ # Members contained or pointed to by the variable.
              # Object with schema name: Variable
            ],
            &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                # unset. A status of a single variable only applies to that variable or
                # expression. The rest of breakpoint data still remains valid. Variables
                # might be reported in error state even when breakpoint is not in final
                # state.
                #
                # The message may refer to variable name with `refers_to` set to
                # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                # In either case variable value and members will be unset.
                #
                # Example of error message applied to name: `Invalid expression syntax`.
                #
                # Example of information message applied to value: `Not captured`.
                #
                # Examples of error message applied to value:
                #
                # *   `Malformed string`,
                # *   `Field f not found in class C`
                # *   `Null pointer dereference`
                # The message can indicate an error or informational status, and refer to
                # specific parts of the containing object.
                # For example, the `Breakpoint.status` field can indicate an error referring
                # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
              &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
              &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                    # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                    # character.
                    #
                    # Examples:
                    #
                    # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                    #     is loaded.  Again, $0 is very important.`
                    # *   `Please pay $$10 to use $0 instead of $1.`
                &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                  &quot;A String&quot;,
                ],
              },
              &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
            },
            &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
            &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                # `var_table_index`, `type` goes next to `value`. The interpretation of
                # a type is agent specific. It is recommended to include the dynamic type
                # rather than a static type of an object.
            &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
            &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                # one variable can reference the same variable in the table. The
                # `var_table_index` field is an index into `variable_table` in Breakpoint.
          },
        ],
        &quot;isFinalState&quot;: True or False, # When true, indicates that this is a final result and the
            # breakpoint state will not change from here on.
        &quot;stackFrames&quot;: [ # The stack at breakpoint time, where stack_frames[0] represents the most
            # recently entered function.
          { # Represents a stack frame context.
            &quot;locals&quot;: [ # Set of local variables at the stack frame location.
                # Note that this might not be populated for all stack frames.
              { # Represents a variable or an argument possibly of a compound object type.
                  # Note how the following variables are represented:
                  #
                  # 1) A simple variable:
                  #
                  #     int x = 5
                  #
                  #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                  #
                  # 2) A compound object:
                  #
                  #     struct T {
                  #         int m1;
                  #         int m2;
                  #     };
                  #     T x = { 3, 7 };
                  #
                  #     {  // Captured variable
                  #         name: &quot;x&quot;,
                  #         type: &quot;T&quot;,
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # 3) A pointer where the pointee was captured:
                  #
                  #     T x = { 3, 7 };
                  #     T* p = &amp;x;
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         type: &quot;T*&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # 4) A pointer where the pointee was not captured:
                  #
                  #     T* p = new T;
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         type: &quot;T*&quot;,
                  #         value: &quot;0x00400400&quot;
                  #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                  #     }
                  #
                  # The status should describe the reason for the missing value,
                  # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                  #
                  # Note that a null pointer should not have members.
                  #
                  # 5) An unnamed value:
                  #
                  #     int* p = new int(7);
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         type: &quot;int*&quot;,
                  #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                  #
                  # 6) An unnamed pointer where the pointee was not captured:
                  #
                  #     int* p = new int(7);
                  #     int** pp = &amp;p;
                  #
                  #     {  // Captured variable
                  #         name: &quot;pp&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         type: &quot;int**&quot;,
                  #         members {
                  #             value: &quot;0x00400400&quot;,
                  #             type: &quot;int*&quot;
                  #             status {
                  #                 is_error: true,
                  #                 description: { format: &quot;unavailable&quot; } }
                  #             }
                  #         }
                  #     }
                  #
                  # To optimize computation, memory and network traffic, variables that
                  # repeat in the output multiple times can be stored once in a shared
                  # variable table and be referenced using the `var_table_index` field.  The
                  # variables stored in the shared table are nameless and are essentially
                  # a partition of the complete variable. To reconstruct the complete
                  # variable, merge the referencing variable with the referenced variable.
                  #
                  # When using the shared variable table, the following variables:
                  #
                  #     T x = { 3, 7 };
                  #     T* p = &amp;x;
                  #     T&amp; r = x;
                  #
                  #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                  #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                  #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                  #
                  #     {  // Shared variable table entry #3:
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # Note that the pointer address is stored with the referencing variable
                  # and not with the referenced variable. This allows the referenced variable
                  # to be shared between pointers and references.
                  #
                  # The type field is optional. The debugger agent may or may not support it.
                &quot;members&quot;: [ # Members contained or pointed to by the variable.
                  # Object with schema name: Variable
                ],
                &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                    # unset. A status of a single variable only applies to that variable or
                    # expression. The rest of breakpoint data still remains valid. Variables
                    # might be reported in error state even when breakpoint is not in final
                    # state.
                    #
                    # The message may refer to variable name with `refers_to` set to
                    # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                    # In either case variable value and members will be unset.
                    #
                    # Example of error message applied to name: `Invalid expression syntax`.
                    #
                    # Example of information message applied to value: `Not captured`.
                    #
                    # Examples of error message applied to value:
                    #
                    # *   `Malformed string`,
                    # *   `Field f not found in class C`
                    # *   `Null pointer dereference`
                    # The message can indicate an error or informational status, and refer to
                    # specific parts of the containing object.
                    # For example, the `Breakpoint.status` field can indicate an error referring
                    # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                  &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                  &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                    &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                        # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                        # character.
                        #
                        # Examples:
                        #
                        # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                        #     is loaded.  Again, $0 is very important.`
                        # *   `Please pay $$10 to use $0 instead of $1.`
                    &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                      &quot;A String&quot;,
                    ],
                  },
                  &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
                },
                &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
                &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                    # `var_table_index`, `type` goes next to `value`. The interpretation of
                    # a type is agent specific. It is recommended to include the dynamic type
                    # rather than a static type of an object.
                &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
                &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                    # one variable can reference the same variable in the table. The
                    # `var_table_index` field is an index into `variable_table` in Breakpoint.
              },
            ],
            &quot;location&quot;: { # Represents a location in the source code. # Source location of the call site.
              &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
              &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
                  # Agents that do not support setting breakpoints on specific columns ignore
                  # this field.
              &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
            },
            &quot;function&quot;: &quot;A String&quot;, # Demangled function name at the call site.
            &quot;arguments&quot;: [ # Set of arguments passed to this function.
                # Note that this might not be populated for all stack frames.
              { # Represents a variable or an argument possibly of a compound object type.
                  # Note how the following variables are represented:
                  #
                  # 1) A simple variable:
                  #
                  #     int x = 5
                  #
                  #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                  #
                  # 2) A compound object:
                  #
                  #     struct T {
                  #         int m1;
                  #         int m2;
                  #     };
                  #     T x = { 3, 7 };
                  #
                  #     {  // Captured variable
                  #         name: &quot;x&quot;,
                  #         type: &quot;T&quot;,
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # 3) A pointer where the pointee was captured:
                  #
                  #     T x = { 3, 7 };
                  #     T* p = &amp;x;
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         type: &quot;T*&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # 4) A pointer where the pointee was not captured:
                  #
                  #     T* p = new T;
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         type: &quot;T*&quot;,
                  #         value: &quot;0x00400400&quot;
                  #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                  #     }
                  #
                  # The status should describe the reason for the missing value,
                  # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                  #
                  # Note that a null pointer should not have members.
                  #
                  # 5) An unnamed value:
                  #
                  #     int* p = new int(7);
                  #
                  #     {   // Captured variable
                  #         name: &quot;p&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         type: &quot;int*&quot;,
                  #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                  #
                  # 6) An unnamed pointer where the pointee was not captured:
                  #
                  #     int* p = new int(7);
                  #     int** pp = &amp;p;
                  #
                  #     {  // Captured variable
                  #         name: &quot;pp&quot;,
                  #         value: &quot;0x00500500&quot;,
                  #         type: &quot;int**&quot;,
                  #         members {
                  #             value: &quot;0x00400400&quot;,
                  #             type: &quot;int*&quot;
                  #             status {
                  #                 is_error: true,
                  #                 description: { format: &quot;unavailable&quot; } }
                  #             }
                  #         }
                  #     }
                  #
                  # To optimize computation, memory and network traffic, variables that
                  # repeat in the output multiple times can be stored once in a shared
                  # variable table and be referenced using the `var_table_index` field.  The
                  # variables stored in the shared table are nameless and are essentially
                  # a partition of the complete variable. To reconstruct the complete
                  # variable, merge the referencing variable with the referenced variable.
                  #
                  # When using the shared variable table, the following variables:
                  #
                  #     T x = { 3, 7 };
                  #     T* p = &amp;x;
                  #     T&amp; r = x;
                  #
                  #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                  #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                  #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                  #
                  #     {  // Shared variable table entry #3:
                  #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                  #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                  #     }
                  #
                  # Note that the pointer address is stored with the referencing variable
                  # and not with the referenced variable. This allows the referenced variable
                  # to be shared between pointers and references.
                  #
                  # The type field is optional. The debugger agent may or may not support it.
                &quot;members&quot;: [ # Members contained or pointed to by the variable.
                  # Object with schema name: Variable
                ],
                &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                    # unset. A status of a single variable only applies to that variable or
                    # expression. The rest of breakpoint data still remains valid. Variables
                    # might be reported in error state even when breakpoint is not in final
                    # state.
                    #
                    # The message may refer to variable name with `refers_to` set to
                    # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                    # In either case variable value and members will be unset.
                    #
                    # Example of error message applied to name: `Invalid expression syntax`.
                    #
                    # Example of information message applied to value: `Not captured`.
                    #
                    # Examples of error message applied to value:
                    #
                    # *   `Malformed string`,
                    # *   `Field f not found in class C`
                    # *   `Null pointer dereference`
                    # The message can indicate an error or informational status, and refer to
                    # specific parts of the containing object.
                    # For example, the `Breakpoint.status` field can indicate an error referring
                    # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                  &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                  &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                    &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                        # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                        # character.
                        #
                        # Examples:
                        #
                        # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                        #     is loaded.  Again, $0 is very important.`
                        # *   `Please pay $$10 to use $0 instead of $1.`
                    &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                      &quot;A String&quot;,
                    ],
                  },
                  &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
                },
                &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
                &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                    # `var_table_index`, `type` goes next to `value`. The interpretation of
                    # a type is agent specific. It is recommended to include the dynamic type
                    # rather than a static type of an object.
                &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
                &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                    # one variable can reference the same variable in the table. The
                    # `var_table_index` field is an index into `variable_table` in Breakpoint.
              },
            ],
          },
        ],
        &quot;condition&quot;: &quot;A String&quot;, # Condition that triggers the breakpoint.
            # The condition is a compound boolean expression composed using expressions
            # in a programming language at the source location.
        &quot;canaryExpireTime&quot;: &quot;A String&quot;, # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
            # is meaningless when the breakpoint is not in CANARY_ACTIVE state.
        &quot;status&quot;: { # Represents a contextual status message. # Breakpoint status.
            #
            # The status includes an error flag and a human readable message.
            # This field is usually unset. The message can be either
            # informational or an error message. Regardless, clients should always
            # display the text message back to the user.
            #
            # Error status indicates complete failure of the breakpoint.
            #
            # Example (non-final state): `Still loading symbols...`
            #
            # Examples (final state):
            #
            # *   `Invalid line number` referring to location
            # *   `Field f not found in class C` referring to condition
            # The message can indicate an error or informational status, and refer to
            # specific parts of the containing object.
            # For example, the `Breakpoint.status` field can indicate an error referring
            # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
          &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
          &quot;description&quot;: { # Represents a message with parameters. # Status message text.
            &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                # character.
                #
                # Examples:
                #
                # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                #     is loaded.  Again, $0 is very important.`
                # *   `Please pay $$10 to use $0 instead of $1.`
            &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
              &quot;A String&quot;,
            ],
          },
          &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
        },
        &quot;state&quot;: &quot;A String&quot;, # The current state of the breakpoint.
        &quot;userEmail&quot;: &quot;A String&quot;, # E-mail address of the user that created this breakpoint
        &quot;action&quot;: &quot;A String&quot;, # Action that the agent should perform when the code at the
            # breakpoint location is hit.
        &quot;logLevel&quot;: &quot;A String&quot;, # Indicates the severity of the log. Only relevant when action is `LOG`.
        &quot;id&quot;: &quot;A String&quot;, # Breakpoint identifier, unique in the scope of the debuggee.
        &quot;location&quot;: { # Represents a location in the source code. # Breakpoint source location.
          &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
          &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
              # Agents that do not support setting breakpoints on specific columns ignore
              # this field.
          &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
        },
        &quot;finalTime&quot;: &quot;A String&quot;, # Time this breakpoint was finalized as seen by the server in seconds
            # resolution.
        &quot;variableTable&quot;: [ # The `variable_table` exists to aid with computation, memory and network
            # traffic optimization.  It enables storing a variable once and reference
            # it from multiple variables, including variables stored in the
            # `variable_table` itself.
            # For example, the same `this` object, which may appear at many levels of
            # the stack, can have all of its data stored once in this table.  The
            # stack frame variables then would hold only a reference to it.
            #
            # The variable `var_table_index` field is an index into this repeated field.
            # The stored objects are nameless and get their name from the referencing
            # variable. The effective variable is a merge of the referencing variable
            # and the referenced variable.
          { # Represents a variable or an argument possibly of a compound object type.
              # Note how the following variables are represented:
              #
              # 1) A simple variable:
              #
              #     int x = 5
              #
              #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
              #
              # 2) A compound object:
              #
              #     struct T {
              #         int m1;
              #         int m2;
              #     };
              #     T x = { 3, 7 };
              #
              #     {  // Captured variable
              #         name: &quot;x&quot;,
              #         type: &quot;T&quot;,
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # 3) A pointer where the pointee was captured:
              #
              #     T x = { 3, 7 };
              #     T* p = &amp;x;
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         type: &quot;T*&quot;,
              #         value: &quot;0x00500500&quot;,
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # 4) A pointer where the pointee was not captured:
              #
              #     T* p = new T;
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         type: &quot;T*&quot;,
              #         value: &quot;0x00400400&quot;
              #         status { is_error: true, description { format: &quot;unavailable&quot; } }
              #     }
              #
              # The status should describe the reason for the missing value,
              # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
              #
              # Note that a null pointer should not have members.
              #
              # 5) An unnamed value:
              #
              #     int* p = new int(7);
              #
              #     {   // Captured variable
              #         name: &quot;p&quot;,
              #         value: &quot;0x00500500&quot;,
              #         type: &quot;int*&quot;,
              #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
              #
              # 6) An unnamed pointer where the pointee was not captured:
              #
              #     int* p = new int(7);
              #     int** pp = &amp;p;
              #
              #     {  // Captured variable
              #         name: &quot;pp&quot;,
              #         value: &quot;0x00500500&quot;,
              #         type: &quot;int**&quot;,
              #         members {
              #             value: &quot;0x00400400&quot;,
              #             type: &quot;int*&quot;
              #             status {
              #                 is_error: true,
              #                 description: { format: &quot;unavailable&quot; } }
              #             }
              #         }
              #     }
              #
              # To optimize computation, memory and network traffic, variables that
              # repeat in the output multiple times can be stored once in a shared
              # variable table and be referenced using the `var_table_index` field.  The
              # variables stored in the shared table are nameless and are essentially
              # a partition of the complete variable. To reconstruct the complete
              # variable, merge the referencing variable with the referenced variable.
              #
              # When using the shared variable table, the following variables:
              #
              #     T x = { 3, 7 };
              #     T* p = &amp;x;
              #     T&amp; r = x;
              #
              #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
              #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
              #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
              #
              #     {  // Shared variable table entry #3:
              #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
              #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
              #     }
              #
              # Note that the pointer address is stored with the referencing variable
              # and not with the referenced variable. This allows the referenced variable
              # to be shared between pointers and references.
              #
              # The type field is optional. The debugger agent may or may not support it.
            &quot;members&quot;: [ # Members contained or pointed to by the variable.
              # Object with schema name: Variable
            ],
            &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                # unset. A status of a single variable only applies to that variable or
                # expression. The rest of breakpoint data still remains valid. Variables
                # might be reported in error state even when breakpoint is not in final
                # state.
                #
                # The message may refer to variable name with `refers_to` set to
                # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                # In either case variable value and members will be unset.
                #
                # Example of error message applied to name: `Invalid expression syntax`.
                #
                # Example of information message applied to value: `Not captured`.
                #
                # Examples of error message applied to value:
                #
                # *   `Malformed string`,
                # *   `Field f not found in class C`
                # *   `Null pointer dereference`
                # The message can indicate an error or informational status, and refer to
                # specific parts of the containing object.
                # For example, the `Breakpoint.status` field can indicate an error referring
                # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
              &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
              &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                    # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                    # character.
                    #
                    # Examples:
                    #
                    # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                    #     is loaded.  Again, $0 is very important.`
                    # *   `Please pay $$10 to use $0 instead of $1.`
                &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                  &quot;A String&quot;,
                ],
              },
              &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
            },
            &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
            &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                # `var_table_index`, `type` goes next to `value`. The interpretation of
                # a type is agent specific. It is recommended to include the dynamic type
                # rather than a static type of an object.
            &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
            &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                # one variable can reference the same variable in the table. The
                # `var_table_index` field is an index into `variable_table` in Breakpoint.
          },
        ],
        &quot;createTime&quot;: &quot;A String&quot;, # Time this breakpoint was created by the server in seconds resolution.
        &quot;logMessageFormat&quot;: &quot;A String&quot;, # Only relevant when action is `LOG`. Defines the message to log when
            # the breakpoint hits. The message may include parameter placeholders `$0`,
            # `$1`, etc. These placeholders are replaced with the evaluated value
            # of the appropriate expression. Expressions not referenced in
            # `log_message_format` are not logged.
            #
            # Example: `Message received, id = $0, count = $1` with
            # `expressions` = `[ message.id, message.count ]`.
        &quot;labels&quot;: { # A set of custom breakpoint properties, populated by the agent, to be
            # displayed to the user.
          &quot;a_key&quot;: &quot;A String&quot;,
        },
      },
    ],
    &quot;nextWaitToken&quot;: &quot;A String&quot;, # A wait token that can be used in the next call to `list` (REST) or
        # `ListBreakpoints` (RPC) to block until the list of breakpoints has changes.
  }</pre>
</div>

<div class="method">
    <code class="details" id="set">set(debuggeeId, body=None, canaryOption=None, clientVersion=None, x__xgafv=None)</code>
  <pre>Sets the breakpoint to the debuggee.

Args:
  debuggeeId: string, Required. ID of the debuggee where the breakpoint is to be set. (required)
  body: object, The request body.
    The object takes the form of:

{ # ------------------------------------------------------------------------------
    # ## Breakpoint (the resource)
    # 
    # Represents the breakpoint specification, status and results.
  &quot;expressions&quot;: [ # List of read-only expressions to evaluate at the breakpoint location.
      # The expressions are composed using expressions in the programming language
      # at the source location. If the breakpoint action is `LOG`, the evaluated
      # expressions are included in log statements.
    &quot;A String&quot;,
  ],
  &quot;evaluatedExpressions&quot;: [ # Values of evaluated expressions at breakpoint time.
      # The evaluated expressions appear in exactly the same order they
      # are listed in the `expressions` field.
      # The `name` field holds the original expression text, the `value` or
      # `members` field holds the result of the evaluated expression.
      # If the expression cannot be evaluated, the `status` inside the `Variable`
      # will indicate an error and contain the error text.
    { # Represents a variable or an argument possibly of a compound object type.
        # Note how the following variables are represented:
        #
        # 1) A simple variable:
        #
        #     int x = 5
        #
        #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
        #
        # 2) A compound object:
        #
        #     struct T {
        #         int m1;
        #         int m2;
        #     };
        #     T x = { 3, 7 };
        #
        #     {  // Captured variable
        #         name: &quot;x&quot;,
        #         type: &quot;T&quot;,
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # 3) A pointer where the pointee was captured:
        #
        #     T x = { 3, 7 };
        #     T* p = &amp;x;
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         type: &quot;T*&quot;,
        #         value: &quot;0x00500500&quot;,
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # 4) A pointer where the pointee was not captured:
        #
        #     T* p = new T;
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         type: &quot;T*&quot;,
        #         value: &quot;0x00400400&quot;
        #         status { is_error: true, description { format: &quot;unavailable&quot; } }
        #     }
        #
        # The status should describe the reason for the missing value,
        # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
        #
        # Note that a null pointer should not have members.
        #
        # 5) An unnamed value:
        #
        #     int* p = new int(7);
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         value: &quot;0x00500500&quot;,
        #         type: &quot;int*&quot;,
        #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
        #
        # 6) An unnamed pointer where the pointee was not captured:
        #
        #     int* p = new int(7);
        #     int** pp = &amp;p;
        #
        #     {  // Captured variable
        #         name: &quot;pp&quot;,
        #         value: &quot;0x00500500&quot;,
        #         type: &quot;int**&quot;,
        #         members {
        #             value: &quot;0x00400400&quot;,
        #             type: &quot;int*&quot;
        #             status {
        #                 is_error: true,
        #                 description: { format: &quot;unavailable&quot; } }
        #             }
        #         }
        #     }
        #
        # To optimize computation, memory and network traffic, variables that
        # repeat in the output multiple times can be stored once in a shared
        # variable table and be referenced using the `var_table_index` field.  The
        # variables stored in the shared table are nameless and are essentially
        # a partition of the complete variable. To reconstruct the complete
        # variable, merge the referencing variable with the referenced variable.
        #
        # When using the shared variable table, the following variables:
        #
        #     T x = { 3, 7 };
        #     T* p = &amp;x;
        #     T&amp; r = x;
        #
        #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
        #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
        #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
        #
        #     {  // Shared variable table entry #3:
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # Note that the pointer address is stored with the referencing variable
        # and not with the referenced variable. This allows the referenced variable
        # to be shared between pointers and references.
        #
        # The type field is optional. The debugger agent may or may not support it.
      &quot;members&quot;: [ # Members contained or pointed to by the variable.
        # Object with schema name: Variable
      ],
      &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
          # unset. A status of a single variable only applies to that variable or
          # expression. The rest of breakpoint data still remains valid. Variables
          # might be reported in error state even when breakpoint is not in final
          # state.
          #
          # The message may refer to variable name with `refers_to` set to
          # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
          # In either case variable value and members will be unset.
          #
          # Example of error message applied to name: `Invalid expression syntax`.
          #
          # Example of information message applied to value: `Not captured`.
          #
          # Examples of error message applied to value:
          #
          # *   `Malformed string`,
          # *   `Field f not found in class C`
          # *   `Null pointer dereference`
          # The message can indicate an error or informational status, and refer to
          # specific parts of the containing object.
          # For example, the `Breakpoint.status` field can indicate an error referring
          # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
        &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
        &quot;description&quot;: { # Represents a message with parameters. # Status message text.
          &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
              # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
              # character.
              #
              # Examples:
              #
              # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
              #     is loaded.  Again, $0 is very important.`
              # *   `Please pay $$10 to use $0 instead of $1.`
          &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
            &quot;A String&quot;,
          ],
        },
        &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
      },
      &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
      &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
          # `var_table_index`, `type` goes next to `value`. The interpretation of
          # a type is agent specific. It is recommended to include the dynamic type
          # rather than a static type of an object.
      &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
      &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
          # one variable can reference the same variable in the table. The
          # `var_table_index` field is an index into `variable_table` in Breakpoint.
    },
  ],
  &quot;isFinalState&quot;: True or False, # When true, indicates that this is a final result and the
      # breakpoint state will not change from here on.
  &quot;stackFrames&quot;: [ # The stack at breakpoint time, where stack_frames[0] represents the most
      # recently entered function.
    { # Represents a stack frame context.
      &quot;locals&quot;: [ # Set of local variables at the stack frame location.
          # Note that this might not be populated for all stack frames.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
      &quot;location&quot;: { # Represents a location in the source code. # Source location of the call site.
        &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
        &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
            # Agents that do not support setting breakpoints on specific columns ignore
            # this field.
        &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
      },
      &quot;function&quot;: &quot;A String&quot;, # Demangled function name at the call site.
      &quot;arguments&quot;: [ # Set of arguments passed to this function.
          # Note that this might not be populated for all stack frames.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
    },
  ],
  &quot;condition&quot;: &quot;A String&quot;, # Condition that triggers the breakpoint.
      # The condition is a compound boolean expression composed using expressions
      # in a programming language at the source location.
  &quot;canaryExpireTime&quot;: &quot;A String&quot;, # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
      # is meaningless when the breakpoint is not in CANARY_ACTIVE state.
  &quot;status&quot;: { # Represents a contextual status message. # Breakpoint status.
      # 
      # The status includes an error flag and a human readable message.
      # This field is usually unset. The message can be either
      # informational or an error message. Regardless, clients should always
      # display the text message back to the user.
      # 
      # Error status indicates complete failure of the breakpoint.
      # 
      # Example (non-final state): `Still loading symbols...`
      # 
      # Examples (final state):
      # 
      # *   `Invalid line number` referring to location
      # *   `Field f not found in class C` referring to condition
      # The message can indicate an error or informational status, and refer to
      # specific parts of the containing object.
      # For example, the `Breakpoint.status` field can indicate an error referring
      # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
    &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
    &quot;description&quot;: { # Represents a message with parameters. # Status message text.
      &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
          # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
          # character.
          #
          # Examples:
          #
          # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
          #     is loaded.  Again, $0 is very important.`
          # *   `Please pay $$10 to use $0 instead of $1.`
      &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
        &quot;A String&quot;,
      ],
    },
    &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
  },
  &quot;state&quot;: &quot;A String&quot;, # The current state of the breakpoint.
  &quot;userEmail&quot;: &quot;A String&quot;, # E-mail address of the user that created this breakpoint
  &quot;action&quot;: &quot;A String&quot;, # Action that the agent should perform when the code at the
      # breakpoint location is hit.
  &quot;logLevel&quot;: &quot;A String&quot;, # Indicates the severity of the log. Only relevant when action is `LOG`.
  &quot;id&quot;: &quot;A String&quot;, # Breakpoint identifier, unique in the scope of the debuggee.
  &quot;location&quot;: { # Represents a location in the source code. # Breakpoint source location.
    &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
    &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
        # Agents that do not support setting breakpoints on specific columns ignore
        # this field.
    &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
  },
  &quot;finalTime&quot;: &quot;A String&quot;, # Time this breakpoint was finalized as seen by the server in seconds
      # resolution.
  &quot;variableTable&quot;: [ # The `variable_table` exists to aid with computation, memory and network
      # traffic optimization.  It enables storing a variable once and reference
      # it from multiple variables, including variables stored in the
      # `variable_table` itself.
      # For example, the same `this` object, which may appear at many levels of
      # the stack, can have all of its data stored once in this table.  The
      # stack frame variables then would hold only a reference to it.
      # 
      # The variable `var_table_index` field is an index into this repeated field.
      # The stored objects are nameless and get their name from the referencing
      # variable. The effective variable is a merge of the referencing variable
      # and the referenced variable.
    { # Represents a variable or an argument possibly of a compound object type.
        # Note how the following variables are represented:
        #
        # 1) A simple variable:
        #
        #     int x = 5
        #
        #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
        #
        # 2) A compound object:
        #
        #     struct T {
        #         int m1;
        #         int m2;
        #     };
        #     T x = { 3, 7 };
        #
        #     {  // Captured variable
        #         name: &quot;x&quot;,
        #         type: &quot;T&quot;,
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # 3) A pointer where the pointee was captured:
        #
        #     T x = { 3, 7 };
        #     T* p = &amp;x;
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         type: &quot;T*&quot;,
        #         value: &quot;0x00500500&quot;,
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # 4) A pointer where the pointee was not captured:
        #
        #     T* p = new T;
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         type: &quot;T*&quot;,
        #         value: &quot;0x00400400&quot;
        #         status { is_error: true, description { format: &quot;unavailable&quot; } }
        #     }
        #
        # The status should describe the reason for the missing value,
        # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
        #
        # Note that a null pointer should not have members.
        #
        # 5) An unnamed value:
        #
        #     int* p = new int(7);
        #
        #     {   // Captured variable
        #         name: &quot;p&quot;,
        #         value: &quot;0x00500500&quot;,
        #         type: &quot;int*&quot;,
        #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
        #
        # 6) An unnamed pointer where the pointee was not captured:
        #
        #     int* p = new int(7);
        #     int** pp = &amp;p;
        #
        #     {  // Captured variable
        #         name: &quot;pp&quot;,
        #         value: &quot;0x00500500&quot;,
        #         type: &quot;int**&quot;,
        #         members {
        #             value: &quot;0x00400400&quot;,
        #             type: &quot;int*&quot;
        #             status {
        #                 is_error: true,
        #                 description: { format: &quot;unavailable&quot; } }
        #             }
        #         }
        #     }
        #
        # To optimize computation, memory and network traffic, variables that
        # repeat in the output multiple times can be stored once in a shared
        # variable table and be referenced using the `var_table_index` field.  The
        # variables stored in the shared table are nameless and are essentially
        # a partition of the complete variable. To reconstruct the complete
        # variable, merge the referencing variable with the referenced variable.
        #
        # When using the shared variable table, the following variables:
        #
        #     T x = { 3, 7 };
        #     T* p = &amp;x;
        #     T&amp; r = x;
        #
        #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
        #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
        #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
        #
        #     {  // Shared variable table entry #3:
        #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
        #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
        #     }
        #
        # Note that the pointer address is stored with the referencing variable
        # and not with the referenced variable. This allows the referenced variable
        # to be shared between pointers and references.
        #
        # The type field is optional. The debugger agent may or may not support it.
      &quot;members&quot;: [ # Members contained or pointed to by the variable.
        # Object with schema name: Variable
      ],
      &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
          # unset. A status of a single variable only applies to that variable or
          # expression. The rest of breakpoint data still remains valid. Variables
          # might be reported in error state even when breakpoint is not in final
          # state.
          #
          # The message may refer to variable name with `refers_to` set to
          # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
          # In either case variable value and members will be unset.
          #
          # Example of error message applied to name: `Invalid expression syntax`.
          #
          # Example of information message applied to value: `Not captured`.
          #
          # Examples of error message applied to value:
          #
          # *   `Malformed string`,
          # *   `Field f not found in class C`
          # *   `Null pointer dereference`
          # The message can indicate an error or informational status, and refer to
          # specific parts of the containing object.
          # For example, the `Breakpoint.status` field can indicate an error referring
          # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
        &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
        &quot;description&quot;: { # Represents a message with parameters. # Status message text.
          &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
              # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
              # character.
              #
              # Examples:
              #
              # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
              #     is loaded.  Again, $0 is very important.`
              # *   `Please pay $$10 to use $0 instead of $1.`
          &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
            &quot;A String&quot;,
          ],
        },
        &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
      },
      &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
      &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
          # `var_table_index`, `type` goes next to `value`. The interpretation of
          # a type is agent specific. It is recommended to include the dynamic type
          # rather than a static type of an object.
      &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
      &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
          # one variable can reference the same variable in the table. The
          # `var_table_index` field is an index into `variable_table` in Breakpoint.
    },
  ],
  &quot;createTime&quot;: &quot;A String&quot;, # Time this breakpoint was created by the server in seconds resolution.
  &quot;logMessageFormat&quot;: &quot;A String&quot;, # Only relevant when action is `LOG`. Defines the message to log when
      # the breakpoint hits. The message may include parameter placeholders `$0`,
      # `$1`, etc. These placeholders are replaced with the evaluated value
      # of the appropriate expression. Expressions not referenced in
      # `log_message_format` are not logged.
      # 
      # Example: `Message received, id = $0, count = $1` with
      # `expressions` = `[ message.id, message.count ]`.
  &quot;labels&quot;: { # A set of custom breakpoint properties, populated by the agent, to be
      # displayed to the user.
    &quot;a_key&quot;: &quot;A String&quot;,
  },
}

  canaryOption: string, The canary option set by the user upon setting breakpoint.
  clientVersion: string, Required. The client version making the call.
Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Response for setting a breakpoint.
    &quot;breakpoint&quot;: { # ------------------------------------------------------------------------------ # Breakpoint resource.
        # The field `id` is guaranteed to be set (in addition to the echoed fields).
        # ## Breakpoint (the resource)
        #
        # Represents the breakpoint specification, status and results.
      &quot;expressions&quot;: [ # List of read-only expressions to evaluate at the breakpoint location.
          # The expressions are composed using expressions in the programming language
          # at the source location. If the breakpoint action is `LOG`, the evaluated
          # expressions are included in log statements.
        &quot;A String&quot;,
      ],
      &quot;evaluatedExpressions&quot;: [ # Values of evaluated expressions at breakpoint time.
          # The evaluated expressions appear in exactly the same order they
          # are listed in the `expressions` field.
          # The `name` field holds the original expression text, the `value` or
          # `members` field holds the result of the evaluated expression.
          # If the expression cannot be evaluated, the `status` inside the `Variable`
          # will indicate an error and contain the error text.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
      &quot;isFinalState&quot;: True or False, # When true, indicates that this is a final result and the
          # breakpoint state will not change from here on.
      &quot;stackFrames&quot;: [ # The stack at breakpoint time, where stack_frames[0] represents the most
          # recently entered function.
        { # Represents a stack frame context.
          &quot;locals&quot;: [ # Set of local variables at the stack frame location.
              # Note that this might not be populated for all stack frames.
            { # Represents a variable or an argument possibly of a compound object type.
                # Note how the following variables are represented:
                #
                # 1) A simple variable:
                #
                #     int x = 5
                #
                #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                #
                # 2) A compound object:
                #
                #     struct T {
                #         int m1;
                #         int m2;
                #     };
                #     T x = { 3, 7 };
                #
                #     {  // Captured variable
                #         name: &quot;x&quot;,
                #         type: &quot;T&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 3) A pointer where the pointee was captured:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00500500&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 4) A pointer where the pointee was not captured:
                #
                #     T* p = new T;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00400400&quot;
                #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                #     }
                #
                # The status should describe the reason for the missing value,
                # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                #
                # Note that a null pointer should not have members.
                #
                # 5) An unnamed value:
                #
                #     int* p = new int(7);
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int*&quot;,
                #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                #
                # 6) An unnamed pointer where the pointee was not captured:
                #
                #     int* p = new int(7);
                #     int** pp = &amp;p;
                #
                #     {  // Captured variable
                #         name: &quot;pp&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int**&quot;,
                #         members {
                #             value: &quot;0x00400400&quot;,
                #             type: &quot;int*&quot;
                #             status {
                #                 is_error: true,
                #                 description: { format: &quot;unavailable&quot; } }
                #             }
                #         }
                #     }
                #
                # To optimize computation, memory and network traffic, variables that
                # repeat in the output multiple times can be stored once in a shared
                # variable table and be referenced using the `var_table_index` field.  The
                # variables stored in the shared table are nameless and are essentially
                # a partition of the complete variable. To reconstruct the complete
                # variable, merge the referencing variable with the referenced variable.
                #
                # When using the shared variable table, the following variables:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #     T&amp; r = x;
                #
                #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                #
                #     {  // Shared variable table entry #3:
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # Note that the pointer address is stored with the referencing variable
                # and not with the referenced variable. This allows the referenced variable
                # to be shared between pointers and references.
                #
                # The type field is optional. The debugger agent may or may not support it.
              &quot;members&quot;: [ # Members contained or pointed to by the variable.
                # Object with schema name: Variable
              ],
              &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                  # unset. A status of a single variable only applies to that variable or
                  # expression. The rest of breakpoint data still remains valid. Variables
                  # might be reported in error state even when breakpoint is not in final
                  # state.
                  #
                  # The message may refer to variable name with `refers_to` set to
                  # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                  # In either case variable value and members will be unset.
                  #
                  # Example of error message applied to name: `Invalid expression syntax`.
                  #
                  # Example of information message applied to value: `Not captured`.
                  #
                  # Examples of error message applied to value:
                  #
                  # *   `Malformed string`,
                  # *   `Field f not found in class C`
                  # *   `Null pointer dereference`
                  # The message can indicate an error or informational status, and refer to
                  # specific parts of the containing object.
                  # For example, the `Breakpoint.status` field can indicate an error referring
                  # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                  &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                      # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                      # character.
                      #
                      # Examples:
                      #
                      # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                      #     is loaded.  Again, $0 is very important.`
                      # *   `Please pay $$10 to use $0 instead of $1.`
                  &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                    &quot;A String&quot;,
                  ],
                },
                &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
              },
              &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
              &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                  # `var_table_index`, `type` goes next to `value`. The interpretation of
                  # a type is agent specific. It is recommended to include the dynamic type
                  # rather than a static type of an object.
              &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
              &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                  # one variable can reference the same variable in the table. The
                  # `var_table_index` field is an index into `variable_table` in Breakpoint.
            },
          ],
          &quot;location&quot;: { # Represents a location in the source code. # Source location of the call site.
            &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
            &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
                # Agents that do not support setting breakpoints on specific columns ignore
                # this field.
            &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
          },
          &quot;function&quot;: &quot;A String&quot;, # Demangled function name at the call site.
          &quot;arguments&quot;: [ # Set of arguments passed to this function.
              # Note that this might not be populated for all stack frames.
            { # Represents a variable or an argument possibly of a compound object type.
                # Note how the following variables are represented:
                #
                # 1) A simple variable:
                #
                #     int x = 5
                #
                #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
                #
                # 2) A compound object:
                #
                #     struct T {
                #         int m1;
                #         int m2;
                #     };
                #     T x = { 3, 7 };
                #
                #     {  // Captured variable
                #         name: &quot;x&quot;,
                #         type: &quot;T&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 3) A pointer where the pointee was captured:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00500500&quot;,
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # 4) A pointer where the pointee was not captured:
                #
                #     T* p = new T;
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         type: &quot;T*&quot;,
                #         value: &quot;0x00400400&quot;
                #         status { is_error: true, description { format: &quot;unavailable&quot; } }
                #     }
                #
                # The status should describe the reason for the missing value,
                # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
                #
                # Note that a null pointer should not have members.
                #
                # 5) An unnamed value:
                #
                #     int* p = new int(7);
                #
                #     {   // Captured variable
                #         name: &quot;p&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int*&quot;,
                #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
                #
                # 6) An unnamed pointer where the pointee was not captured:
                #
                #     int* p = new int(7);
                #     int** pp = &amp;p;
                #
                #     {  // Captured variable
                #         name: &quot;pp&quot;,
                #         value: &quot;0x00500500&quot;,
                #         type: &quot;int**&quot;,
                #         members {
                #             value: &quot;0x00400400&quot;,
                #             type: &quot;int*&quot;
                #             status {
                #                 is_error: true,
                #                 description: { format: &quot;unavailable&quot; } }
                #             }
                #         }
                #     }
                #
                # To optimize computation, memory and network traffic, variables that
                # repeat in the output multiple times can be stored once in a shared
                # variable table and be referenced using the `var_table_index` field.  The
                # variables stored in the shared table are nameless and are essentially
                # a partition of the complete variable. To reconstruct the complete
                # variable, merge the referencing variable with the referenced variable.
                #
                # When using the shared variable table, the following variables:
                #
                #     T x = { 3, 7 };
                #     T* p = &amp;x;
                #     T&amp; r = x;
                #
                #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
                #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
                #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
                #
                #     {  // Shared variable table entry #3:
                #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
                #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
                #     }
                #
                # Note that the pointer address is stored with the referencing variable
                # and not with the referenced variable. This allows the referenced variable
                # to be shared between pointers and references.
                #
                # The type field is optional. The debugger agent may or may not support it.
              &quot;members&quot;: [ # Members contained or pointed to by the variable.
                # Object with schema name: Variable
              ],
              &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
                  # unset. A status of a single variable only applies to that variable or
                  # expression. The rest of breakpoint data still remains valid. Variables
                  # might be reported in error state even when breakpoint is not in final
                  # state.
                  #
                  # The message may refer to variable name with `refers_to` set to
                  # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
                  # In either case variable value and members will be unset.
                  #
                  # Example of error message applied to name: `Invalid expression syntax`.
                  #
                  # Example of information message applied to value: `Not captured`.
                  #
                  # Examples of error message applied to value:
                  #
                  # *   `Malformed string`,
                  # *   `Field f not found in class C`
                  # *   `Null pointer dereference`
                  # The message can indicate an error or informational status, and refer to
                  # specific parts of the containing object.
                  # For example, the `Breakpoint.status` field can indicate an error referring
                  # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
                &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
                &quot;description&quot;: { # Represents a message with parameters. # Status message text.
                  &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                      # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                      # character.
                      #
                      # Examples:
                      #
                      # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                      #     is loaded.  Again, $0 is very important.`
                      # *   `Please pay $$10 to use $0 instead of $1.`
                  &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                    &quot;A String&quot;,
                  ],
                },
                &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
              },
              &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
              &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
                  # `var_table_index`, `type` goes next to `value`. The interpretation of
                  # a type is agent specific. It is recommended to include the dynamic type
                  # rather than a static type of an object.
              &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
              &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
                  # one variable can reference the same variable in the table. The
                  # `var_table_index` field is an index into `variable_table` in Breakpoint.
            },
          ],
        },
      ],
      &quot;condition&quot;: &quot;A String&quot;, # Condition that triggers the breakpoint.
          # The condition is a compound boolean expression composed using expressions
          # in a programming language at the source location.
      &quot;canaryExpireTime&quot;: &quot;A String&quot;, # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
          # is meaningless when the breakpoint is not in CANARY_ACTIVE state.
      &quot;status&quot;: { # Represents a contextual status message. # Breakpoint status.
          #
          # The status includes an error flag and a human readable message.
          # This field is usually unset. The message can be either
          # informational or an error message. Regardless, clients should always
          # display the text message back to the user.
          #
          # Error status indicates complete failure of the breakpoint.
          #
          # Example (non-final state): `Still loading symbols...`
          #
          # Examples (final state):
          #
          # *   `Invalid line number` referring to location
          # *   `Field f not found in class C` referring to condition
          # The message can indicate an error or informational status, and refer to
          # specific parts of the containing object.
          # For example, the `Breakpoint.status` field can indicate an error referring
          # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
        &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
        &quot;description&quot;: { # Represents a message with parameters. # Status message text.
          &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
              # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
              # character.
              #
              # Examples:
              #
              # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
              #     is loaded.  Again, $0 is very important.`
              # *   `Please pay $$10 to use $0 instead of $1.`
          &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
            &quot;A String&quot;,
          ],
        },
        &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
      },
      &quot;state&quot;: &quot;A String&quot;, # The current state of the breakpoint.
      &quot;userEmail&quot;: &quot;A String&quot;, # E-mail address of the user that created this breakpoint
      &quot;action&quot;: &quot;A String&quot;, # Action that the agent should perform when the code at the
          # breakpoint location is hit.
      &quot;logLevel&quot;: &quot;A String&quot;, # Indicates the severity of the log. Only relevant when action is `LOG`.
      &quot;id&quot;: &quot;A String&quot;, # Breakpoint identifier, unique in the scope of the debuggee.
      &quot;location&quot;: { # Represents a location in the source code. # Breakpoint source location.
        &quot;path&quot;: &quot;A String&quot;, # Path to the source file within the source context of the target binary.
        &quot;column&quot;: 42, # Column within a line. The first column in a line as the value `1`.
            # Agents that do not support setting breakpoints on specific columns ignore
            # this field.
        &quot;line&quot;: 42, # Line inside the file. The first line in the file has the value `1`.
      },
      &quot;finalTime&quot;: &quot;A String&quot;, # Time this breakpoint was finalized as seen by the server in seconds
          # resolution.
      &quot;variableTable&quot;: [ # The `variable_table` exists to aid with computation, memory and network
          # traffic optimization.  It enables storing a variable once and reference
          # it from multiple variables, including variables stored in the
          # `variable_table` itself.
          # For example, the same `this` object, which may appear at many levels of
          # the stack, can have all of its data stored once in this table.  The
          # stack frame variables then would hold only a reference to it.
          #
          # The variable `var_table_index` field is an index into this repeated field.
          # The stored objects are nameless and get their name from the referencing
          # variable. The effective variable is a merge of the referencing variable
          # and the referenced variable.
        { # Represents a variable or an argument possibly of a compound object type.
            # Note how the following variables are represented:
            #
            # 1) A simple variable:
            #
            #     int x = 5
            #
            #     { name: &quot;x&quot;, value: &quot;5&quot;, type: &quot;int&quot; }  // Captured variable
            #
            # 2) A compound object:
            #
            #     struct T {
            #         int m1;
            #         int m2;
            #     };
            #     T x = { 3, 7 };
            #
            #     {  // Captured variable
            #         name: &quot;x&quot;,
            #         type: &quot;T&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 3) A pointer where the pointee was captured:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00500500&quot;,
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # 4) A pointer where the pointee was not captured:
            #
            #     T* p = new T;
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         type: &quot;T*&quot;,
            #         value: &quot;0x00400400&quot;
            #         status { is_error: true, description { format: &quot;unavailable&quot; } }
            #     }
            #
            # The status should describe the reason for the missing value,
            # such as `&lt;optimized out&gt;`, `&lt;inaccessible&gt;`, `&lt;pointers limit reached&gt;`.
            #
            # Note that a null pointer should not have members.
            #
            # 5) An unnamed value:
            #
            #     int* p = new int(7);
            #
            #     {   // Captured variable
            #         name: &quot;p&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int*&quot;,
            #         members { value: &quot;7&quot;, type: &quot;int&quot; } }
            #
            # 6) An unnamed pointer where the pointee was not captured:
            #
            #     int* p = new int(7);
            #     int** pp = &amp;p;
            #
            #     {  // Captured variable
            #         name: &quot;pp&quot;,
            #         value: &quot;0x00500500&quot;,
            #         type: &quot;int**&quot;,
            #         members {
            #             value: &quot;0x00400400&quot;,
            #             type: &quot;int*&quot;
            #             status {
            #                 is_error: true,
            #                 description: { format: &quot;unavailable&quot; } }
            #             }
            #         }
            #     }
            #
            # To optimize computation, memory and network traffic, variables that
            # repeat in the output multiple times can be stored once in a shared
            # variable table and be referenced using the `var_table_index` field.  The
            # variables stored in the shared table are nameless and are essentially
            # a partition of the complete variable. To reconstruct the complete
            # variable, merge the referencing variable with the referenced variable.
            #
            # When using the shared variable table, the following variables:
            #
            #     T x = { 3, 7 };
            #     T* p = &amp;x;
            #     T&amp; r = x;
            #
            #     { name: &quot;x&quot;, var_table_index: 3, type: &quot;T&quot; }  // Captured variables
            #     { name: &quot;p&quot;, value &quot;0x00500500&quot;, type=&quot;T*&quot;, var_table_index: 3 }
            #     { name: &quot;r&quot;, type=&quot;T&amp;&quot;, var_table_index: 3 }
            #
            #     {  // Shared variable table entry #3:
            #         members { name: &quot;m1&quot;, value: &quot;3&quot;, type: &quot;int&quot; },
            #         members { name: &quot;m2&quot;, value: &quot;7&quot;, type: &quot;int&quot; }
            #     }
            #
            # Note that the pointer address is stored with the referencing variable
            # and not with the referenced variable. This allows the referenced variable
            # to be shared between pointers and references.
            #
            # The type field is optional. The debugger agent may or may not support it.
          &quot;members&quot;: [ # Members contained or pointed to by the variable.
            # Object with schema name: Variable
          ],
          &quot;status&quot;: { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
              # unset. A status of a single variable only applies to that variable or
              # expression. The rest of breakpoint data still remains valid. Variables
              # might be reported in error state even when breakpoint is not in final
              # state.
              #
              # The message may refer to variable name with `refers_to` set to
              # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
              # In either case variable value and members will be unset.
              #
              # Example of error message applied to name: `Invalid expression syntax`.
              #
              # Example of information message applied to value: `Not captured`.
              #
              # Examples of error message applied to value:
              #
              # *   `Malformed string`,
              # *   `Field f not found in class C`
              # *   `Null pointer dereference`
              # The message can indicate an error or informational status, and refer to
              # specific parts of the containing object.
              # For example, the `Breakpoint.status` field can indicate an error referring
              # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
            &quot;isError&quot;: True or False, # Distinguishes errors from informational messages.
            &quot;description&quot;: { # Represents a message with parameters. # Status message text.
              &quot;format&quot;: &quot;A String&quot;, # Format template for the message. The `format` uses placeholders `$0`,
                  # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
                  # character.
                  #
                  # Examples:
                  #
                  # *   `Failed to load &#x27;$0&#x27; which helps debug $1 the first time it
                  #     is loaded.  Again, $0 is very important.`
                  # *   `Please pay $$10 to use $0 instead of $1.`
              &quot;parameters&quot;: [ # Optional parameters to be embedded into the message.
                &quot;A String&quot;,
              ],
            },
            &quot;refersTo&quot;: &quot;A String&quot;, # Reference to which the message applies.
          },
          &quot;name&quot;: &quot;A String&quot;, # Name of the variable, if any.
          &quot;type&quot;: &quot;A String&quot;, # Variable type (e.g. `MyClass`). If the variable is split with
              # `var_table_index`, `type` goes next to `value`. The interpretation of
              # a type is agent specific. It is recommended to include the dynamic type
              # rather than a static type of an object.
          &quot;value&quot;: &quot;A String&quot;, # Simple value of the variable.
          &quot;varTableIndex&quot;: 42, # Reference to a variable in the shared variable table. More than
              # one variable can reference the same variable in the table. The
              # `var_table_index` field is an index into `variable_table` in Breakpoint.
        },
      ],
      &quot;createTime&quot;: &quot;A String&quot;, # Time this breakpoint was created by the server in seconds resolution.
      &quot;logMessageFormat&quot;: &quot;A String&quot;, # Only relevant when action is `LOG`. Defines the message to log when
          # the breakpoint hits. The message may include parameter placeholders `$0`,
          # `$1`, etc. These placeholders are replaced with the evaluated value
          # of the appropriate expression. Expressions not referenced in
          # `log_message_format` are not logged.
          #
          # Example: `Message received, id = $0, count = $1` with
          # `expressions` = `[ message.id, message.count ]`.
      &quot;labels&quot;: { # A set of custom breakpoint properties, populated by the agent, to be
          # displayed to the user.
        &quot;a_key&quot;: &quot;A String&quot;,
      },
    },
  }</pre>
</div>

</body></html>