<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="dialogflow_v3.html">Dialogflow API</a> . <a href="dialogflow_v3.projects.html">projects</a> . <a href="dialogflow_v3.projects.locations.html">locations</a> . <a href="dialogflow_v3.projects.locations.securitySettings.html">securitySettings</a></h1>
<h2>Instance Methods</h2>
<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="#create">create(parent, body=None, x__xgafv=None)</a></code></p>
<p class="firstline">Create security settings in the specified location.</p>
<p class="toc_element">
  <code><a href="#delete">delete(name, x__xgafv=None)</a></code></p>
<p class="firstline">Deletes the specified SecuritySettings.</p>
<p class="toc_element">
  <code><a href="#get">get(name, x__xgafv=None)</a></code></p>
<p class="firstline">Retrieves the specified SecuritySettings. The returned settings may be stale by up to 1 minute.</p>
<p class="toc_element">
  <code><a href="#list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</a></code></p>
<p class="firstline">Returns the list of all security settings in the specified location.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(name, body=None, updateMask=None, x__xgafv=None)</a></code></p>
<p class="firstline">Updates the specified SecuritySettings.</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="create">create(parent, body=None, x__xgafv=None)</code>
  <pre>Create security settings in the specified location.

Args:
  parent: string, Required. The location to create an SecuritySettings for. Format: `projects//locations/`. (required)
  body: object, The request body.
    The object takes the form of:

{ # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
  &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
  &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
    &quot;A String&quot;,
  ],
  &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
  &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
  &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
}

  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
  &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
  &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
    &quot;A String&quot;,
  ],
  &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
  &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
  &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
}</pre>
</div>

<div class="method">
    <code class="details" id="delete">delete(name, x__xgafv=None)</code>
  <pre>Deletes the specified SecuritySettings.

Args:
  name: string, Required. The name of the SecuritySettings to delete. Format: `projects//locations//securitySettings/`. (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="get">get(name, x__xgafv=None)</code>
  <pre>Retrieves the specified SecuritySettings. The returned settings may be stale by up to 1 minute.

Args:
  name: string, Required. Resource name of the settings. Format: `projects//locations//securitySettings/`. (required)
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
  &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
  &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
    &quot;A String&quot;,
  ],
  &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
  &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
  &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
}</pre>
</div>

<div class="method">
    <code class="details" id="list">list(parent, pageSize=None, pageToken=None, x__xgafv=None)</code>
  <pre>Returns the list of all security settings in the specified location.

Args:
  parent: string, Required. The location to list all security settings for. Format: `projects//locations/`. (required)
  pageSize: integer, The maximum number of items to return in a single page. By default 20 and at most 100.
  pageToken: string, The next_page_token value returned from a previous list request.
  x__xgafv: string, V1 error format.
    Allowed values
      1 - v1 error format
      2 - v2 error format

Returns:
  An object of the form:

    { # The response message for SecuritySettings.ListSecuritySettings.
  &quot;nextPageToken&quot;: &quot;A String&quot;, # Token to retrieve the next page of results, or empty if there are no more results in the list.
  &quot;securitySettings&quot;: [ # The list of security settings.
    { # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
      &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
      &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
      &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
      &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
        &quot;A String&quot;,
      ],
      &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
      &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
      &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
    },
  ],
}</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call &#x27;execute()&#x27; on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(name, body=None, updateMask=None, x__xgafv=None)</code>
  <pre>Updates the specified SecuritySettings.

Args:
  name: string, Required. Resource name of the settings. Format: `projects//locations//securitySettings/`. (required)
  body: object, The request body.
    The object takes the form of:

{ # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
  &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
  &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
    &quot;A String&quot;,
  ],
  &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
  &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
  &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
}

  updateMask: string, Required. The mask to control which fields get updated. If the mask is not present, all fields 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:

    { # Represents the settings related to security issues, such as data redaction and data retention. It may take hours for updates on the settings to propagate to all the related components and take effect.
  &quot;displayName&quot;: &quot;A String&quot;, # Required. The human-readable name of the security settings, unique within the location.
  &quot;inspectTemplate&quot;: &quot;A String&quot;, # DLP inspect template name. Use this template to define inspect base settings. If empty, we use the default DLP inspect config. The template name will have one of the following formats: `projects/PROJECT_ID/inspectTemplates/TEMPLATE_ID` OR `organizations/ORGANIZATION_ID/inspectTemplates/TEMPLATE_ID`
  &quot;name&quot;: &quot;A String&quot;, # Required. Resource name of the settings. Format: `projects//locations//securitySettings/`.
  &quot;purgeDataTypes&quot;: [ # List of types of data to remove when retention settings triggers purge.
    &quot;A String&quot;,
  ],
  &quot;redactionScope&quot;: &quot;A String&quot;, # Defines the data for which Dialogflow applies redaction. Dialogflow does not redact data that it does not have access to – for example, Cloud logging.
  &quot;redactionStrategy&quot;: &quot;A String&quot;, # Strategy that defines how we do redaction.
  &quot;retentionWindowDays&quot;: 42, # Retains data in interaction logging for the specified number of days. This does not apply to Cloud logging, which is owned by the user - not Dialogflow. User must Set a value lower than Dialogflow&#x27;s default 30d TTL. Setting a value higher than that has no effect. A missing value or setting to 0 also means we use Dialogflow&#x27;s default TTL. Note: Interaction logging is a limited access feature. Talk to your Google representative to check availability for you.
}</pre>
</div>

</body></html>