<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="accessapproval_v1.html">Access Approval API</a> . <a href="accessapproval_v1.projects.html">projects</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="accessapproval_v1.projects.approvalRequests.html">approvalRequests()</a></code>
</p>
<p class="firstline">Returns the approvalRequests Resource.</p>

<p class="toc_element">
  <code><a href="#close">close()</a></code></p>
<p class="firstline">Close httplib2 connections.</p>
<p class="toc_element">
  <code><a href="#deleteAccessApprovalSettings">deleteAccessApprovalSettings(name, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes the settings associated with a project, folder, or organization. This will have the effect of disabling Access Approval for the project, folder, or organization, but only if all ancestors also have Access Approval disabled. If Access Approval is enabled at a higher level of the hierarchy, then Access Approval will still be enabled at this level as the settings are inherited.</p>
<p class="toc_element">
  <code><a href="#getAccessApprovalSettings">getAccessApprovalSettings(name, x__xgafv=None)</a></code></p>
<p class="firstline">Gets the settings associated with a project, folder, or organization.</p>
<p class="toc_element">
  <code><a href="#updateAccessApprovalSettings">updateAccessApprovalSettings(name, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates the settings associated with a project, folder, or organization. Settings to update are determined by the value of field_mask.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="close">close()</code>
  <pre>Close httplib2 connections.</pre>
</div>

<div class="method">
    <code class="details" id="deleteAccessApprovalSettings">deleteAccessApprovalSettings(name, x__xgafv=None)</code>
  <pre>Deletes the settings associated with a project, folder, or organization. This will have the effect of disabling Access Approval for the project, folder, or organization, but only if all ancestors also have Access Approval disabled. If Access Approval is enabled at a higher level of the hierarchy, then Access Approval will still be enabled at this level as the settings are inherited.

Args:
  name: string, Name of the AccessApprovalSettings to delete. (required)
  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="getAccessApprovalSettings">getAccessApprovalSettings(name, x__xgafv=None)</code>
  <pre>Gets the settings associated with a project, folder, or organization.

Args:
  name: string, Name of the AccessApprovalSettings to retrieve. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Settings on a Project/Folder/Organization related to Access Approval.
    &quot;enrolledServices&quot;: [ # A list of Google Cloud Services for which the given resource has Access Approval enrolled. Access requests for the resource given by name against any of these services contained here will be required to have explicit approval. If name refers to an organization, enrollment can be done for individual services. If name refers to a folder or project, enrollment can only be done on an all or nothing basis. If a cloud_product is repeated in this list, the first entry will be honored and all following entries will be discarded. A maximum of 10 enrolled services will be enforced, to be expanded as the set of supported services is expanded.
      { # Represents the enrollment of a cloud resource into a specific service.
        &quot;enrollmentLevel&quot;: &quot;A String&quot;, # The enrollment level of the service.
        &quot;cloudProduct&quot;: &quot;A String&quot;, # The product for which Access Approval will be enrolled. Allowed values are listed below (case-sensitive): * all * App Engine * BigQuery * Cloud Bigtable * Cloud Key Management Service * Compute Engine * Cloud Dataflow * Cloud Identity and Access Management * Cloud Pub/Sub * Cloud Storage * Persistent Disk Note: These values are supported as input for legacy purposes, but will not be returned from the API. * all * appengine.googleapis.com * bigquery.googleapis.com * bigtable.googleapis.com * cloudkms.googleapis.com * compute.googleapis.com * dataflow.googleapis.com * iam.googleapis.com * pubsub.googleapis.com * storage.googleapis.com Calls to UpdateAccessApprovalSettings using &#x27;all&#x27; or any of the XXX.googleapis.com will be translated to the associated product name (&#x27;all&#x27;, &#x27;App Engine&#x27;, etc.). Note: &#x27;all&#x27; will enroll the resource in all products supported at both &#x27;GA&#x27; and &#x27;Preview&#x27; levels. More information about levels of support is available at https://cloud.google.com/access-approval/docs/supported-services
      },
    ],
    &quot;enrolledAncestor&quot;: True or False, # Output only. This field is read only (not settable via UpdateAccessAccessApprovalSettings method). If the field is true, that indicates that at least one service is enrolled for Access Approval in one or more ancestors of the Project or Folder (this field will always be unset for the organization since organizations do not have ancestors).
    &quot;notificationEmails&quot;: [ # A list of email addresses to which notifications relating to approval requests should be sent. Notifications relating to a resource will be sent to all emails in the settings of ancestor resources of that resource. A maximum of 50 email addresses are allowed.
      &quot;A String&quot;,
    ],
    &quot;name&quot;: &quot;A String&quot;, # The resource name of the settings. Format is one of: * &quot;projects/{project}/accessApprovalSettings&quot; * &quot;folders/{folder}/accessApprovalSettings&quot; * &quot;organizations/{organization}/accessApprovalSettings&quot;
  }</pre>
</div>

<div class="method">
    <code class="details" id="updateAccessApprovalSettings">updateAccessApprovalSettings(name, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates the settings associated with a project, folder, or organization. Settings to update are determined by the value of field_mask.

Args:
  name: string, The resource name of the settings. Format is one of: * &quot;projects/{project}/accessApprovalSettings&quot; * &quot;folders/{folder}/accessApprovalSettings&quot; * &quot;organizations/{organization}/accessApprovalSettings&quot; (required)
  body: object, The request body.
    The object takes the form of:

{ # Settings on a Project/Folder/Organization related to Access Approval.
  &quot;enrolledServices&quot;: [ # A list of Google Cloud Services for which the given resource has Access Approval enrolled. Access requests for the resource given by name against any of these services contained here will be required to have explicit approval. If name refers to an organization, enrollment can be done for individual services. If name refers to a folder or project, enrollment can only be done on an all or nothing basis. If a cloud_product is repeated in this list, the first entry will be honored and all following entries will be discarded. A maximum of 10 enrolled services will be enforced, to be expanded as the set of supported services is expanded.
    { # Represents the enrollment of a cloud resource into a specific service.
      &quot;enrollmentLevel&quot;: &quot;A String&quot;, # The enrollment level of the service.
      &quot;cloudProduct&quot;: &quot;A String&quot;, # The product for which Access Approval will be enrolled. Allowed values are listed below (case-sensitive): * all * App Engine * BigQuery * Cloud Bigtable * Cloud Key Management Service * Compute Engine * Cloud Dataflow * Cloud Identity and Access Management * Cloud Pub/Sub * Cloud Storage * Persistent Disk Note: These values are supported as input for legacy purposes, but will not be returned from the API. * all * appengine.googleapis.com * bigquery.googleapis.com * bigtable.googleapis.com * cloudkms.googleapis.com * compute.googleapis.com * dataflow.googleapis.com * iam.googleapis.com * pubsub.googleapis.com * storage.googleapis.com Calls to UpdateAccessApprovalSettings using &#x27;all&#x27; or any of the XXX.googleapis.com will be translated to the associated product name (&#x27;all&#x27;, &#x27;App Engine&#x27;, etc.). Note: &#x27;all&#x27; will enroll the resource in all products supported at both &#x27;GA&#x27; and &#x27;Preview&#x27; levels. More information about levels of support is available at https://cloud.google.com/access-approval/docs/supported-services
    },
  ],
  &quot;enrolledAncestor&quot;: True or False, # Output only. This field is read only (not settable via UpdateAccessAccessApprovalSettings method). If the field is true, that indicates that at least one service is enrolled for Access Approval in one or more ancestors of the Project or Folder (this field will always be unset for the organization since organizations do not have ancestors).
  &quot;notificationEmails&quot;: [ # A list of email addresses to which notifications relating to approval requests should be sent. Notifications relating to a resource will be sent to all emails in the settings of ancestor resources of that resource. A maximum of 50 email addresses are allowed.
    &quot;A String&quot;,
  ],
  &quot;name&quot;: &quot;A String&quot;, # The resource name of the settings. Format is one of: * &quot;projects/{project}/accessApprovalSettings&quot; * &quot;folders/{folder}/accessApprovalSettings&quot; * &quot;organizations/{organization}/accessApprovalSettings&quot;
}

  updateMask: string, The update mask applies to the settings. Only the top level fields of AccessApprovalSettings (notification_emails &amp; enrolled_services) are supported. For each field, if it is included, the currently stored value will be entirely overwritten with the value of the field passed in this request. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If this field is left unset, only the notification_emails field will be updated.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Settings on a Project/Folder/Organization related to Access Approval.
    &quot;enrolledServices&quot;: [ # A list of Google Cloud Services for which the given resource has Access Approval enrolled. Access requests for the resource given by name against any of these services contained here will be required to have explicit approval. If name refers to an organization, enrollment can be done for individual services. If name refers to a folder or project, enrollment can only be done on an all or nothing basis. If a cloud_product is repeated in this list, the first entry will be honored and all following entries will be discarded. A maximum of 10 enrolled services will be enforced, to be expanded as the set of supported services is expanded.
      { # Represents the enrollment of a cloud resource into a specific service.
        &quot;enrollmentLevel&quot;: &quot;A String&quot;, # The enrollment level of the service.
        &quot;cloudProduct&quot;: &quot;A String&quot;, # The product for which Access Approval will be enrolled. Allowed values are listed below (case-sensitive): * all * App Engine * BigQuery * Cloud Bigtable * Cloud Key Management Service * Compute Engine * Cloud Dataflow * Cloud Identity and Access Management * Cloud Pub/Sub * Cloud Storage * Persistent Disk Note: These values are supported as input for legacy purposes, but will not be returned from the API. * all * appengine.googleapis.com * bigquery.googleapis.com * bigtable.googleapis.com * cloudkms.googleapis.com * compute.googleapis.com * dataflow.googleapis.com * iam.googleapis.com * pubsub.googleapis.com * storage.googleapis.com Calls to UpdateAccessApprovalSettings using &#x27;all&#x27; or any of the XXX.googleapis.com will be translated to the associated product name (&#x27;all&#x27;, &#x27;App Engine&#x27;, etc.). Note: &#x27;all&#x27; will enroll the resource in all products supported at both &#x27;GA&#x27; and &#x27;Preview&#x27; levels. More information about levels of support is available at https://cloud.google.com/access-approval/docs/supported-services
      },
    ],
    &quot;enrolledAncestor&quot;: True or False, # Output only. This field is read only (not settable via UpdateAccessAccessApprovalSettings method). If the field is true, that indicates that at least one service is enrolled for Access Approval in one or more ancestors of the Project or Folder (this field will always be unset for the organization since organizations do not have ancestors).
    &quot;notificationEmails&quot;: [ # A list of email addresses to which notifications relating to approval requests should be sent. Notifications relating to a resource will be sent to all emails in the settings of ancestor resources of that resource. A maximum of 50 email addresses are allowed.
      &quot;A String&quot;,
    ],
    &quot;name&quot;: &quot;A String&quot;, # The resource name of the settings. Format is one of: * &quot;projects/{project}/accessApprovalSettings&quot; * &quot;folders/{folder}/accessApprovalSettings&quot; * &quot;organizations/{organization}/accessApprovalSettings&quot;
  }</pre>
</div>

</body></html>