googleapis
Version:
Google APIs Client Library for Node.js
866 lines • 830 kB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace networksecurity_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Network Security API
*
*
*
* @example
* ```js
* const {google} = require('googleapis');
* const networksecurity = google.networksecurity('v1');
* ```
*/
export class Networksecurity {
context: APIRequestContext;
organizations: Resource$Organizations;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Request used by the AddAddressGroupItems method.
*/
export interface Schema$AddAddressGroupItemsRequest {
/**
* Required. List of items to add.
*/
items?: string[] | null;
/**
* Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
*/
requestId?: string | null;
}
/**
* AddressGroup is a resource that specifies how a collection of IP/DNS used in Firewall Policy.
*/
export interface Schema$AddressGroup {
/**
* Required. Capacity of the Address Group
*/
capacity?: number | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Optional. List of items.
*/
items?: string[] | null;
/**
* Optional. Set of label tags associated with the AddressGroup resource.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. Name of the AddressGroup resource. It matches pattern `projects/x/locations/{location\}/addressGroups/`.
*/
name?: string | null;
/**
* Optional. List of supported purposes of the Address Group.
*/
purpose?: string[] | null;
/**
* Output only. Server-defined fully-qualified URL for this resource.
*/
selfLink?: string | null;
/**
* Required. The type of the Address Group. Possible values are "IPv4" or "IPV6".
*/
type?: string | null;
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
}
/**
* Defines what action to take for antivirus threats per protocol.
*/
export interface Schema$AntivirusOverride {
/**
* Required. Threat action override. For some threat types, only a subset of actions applies.
*/
action?: string | null;
/**
* Required. Protocol to match.
*/
protocol?: string | null;
}
/**
* AuthorizationPolicy is a resource that specifies how a server should authorize incoming connections. This resource in itself does not change the configuration unless it's attached to a target https proxy or endpoint config selector resource.
*/
export interface Schema$AuthorizationPolicy {
/**
* Required. The action to take when a rule match is found. Possible values are "ALLOW" or "DENY".
*/
action?: string | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Optional. Set of label tags associated with the AuthorizationPolicy resource.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. Name of the AuthorizationPolicy resource. It matches pattern `projects/{project\}/locations/{location\}/authorizationPolicies/`.
*/
name?: string | null;
/**
* Optional. List of rules to match. Note that at least one of the rules must match in order for the action specified in the 'action' field to be taken. A rule is a match if there is a matching source and destination. If left blank, the action specified in the `action` field will be applied on every request.
*/
rules?: Schema$Rule[];
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
}
/**
* `AuthzPolicy` is a resource that allows to forward traffic to a callout backend designed to scan the traffic for security purposes.
*/
export interface Schema$AuthzPolicy {
/**
* Required. Can be one of `ALLOW`, `DENY`, `CUSTOM`. When the action is `CUSTOM`, `customProvider` must be specified. When the action is `ALLOW`, only requests matching the policy will be allowed. When the action is `DENY`, only requests matching the policy will be denied. When a request arrives, the policies are evaluated in the following order: 1. If there is a `CUSTOM` policy that matches the request, the `CUSTOM` policy is evaluated using the custom authorization providers and the request is denied if the provider rejects the request. 2. If there are any `DENY` policies that match the request, the request is denied. 3. If there are no `ALLOW` policies for the resource or if any of the `ALLOW` policies match the request, the request is allowed. 4. Else the request is denied by default if none of the configured AuthzPolicies with `ALLOW` action match the request.
*/
action?: string | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Required if the action is `CUSTOM`. Allows delegating authorization decisions to Cloud IAP or to Service Extensions. One of `cloudIap` or `authzExtension` must be specified.
*/
customProvider?: Schema$AuthzPolicyCustomProvider;
/**
* Optional. A human-readable description of the resource.
*/
description?: string | null;
/**
* Optional. A list of authorization HTTP rules to match against the incoming request. A policy match occurs when at least one HTTP rule matches the request or when no HTTP rules are specified in the policy. At least one HTTP Rule is required for Allow or Deny Action. Limited to 5 rules.
*/
httpRules?: Schema$AuthzPolicyAuthzRule[];
/**
* Optional. Set of labels associated with the `AuthzPolicy` resource. The format must comply with [the following requirements](/compute/docs/labeling-resources#requirements).
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. Identifier. Name of the `AuthzPolicy` resource in the following format: `projects/{project\}/locations/{location\}/authzPolicies/{authz_policy\}`.
*/
name?: string | null;
/**
* Required. Specifies the set of resources to which this policy should be applied to.
*/
target?: Schema$AuthzPolicyTarget;
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
}
/**
* Conditions to match against the incoming request.
*/
export interface Schema$AuthzPolicyAuthzRule {
/**
* Optional. Describes properties of a source of a request.
*/
from?: Schema$AuthzPolicyAuthzRuleFrom;
/**
* Optional. Describes properties of a target of a request.
*/
to?: Schema$AuthzPolicyAuthzRuleTo;
/**
* Optional. CEL expression that describes the conditions to be satisfied for the action. The result of the CEL expression is ANDed with the from and to. Refer to the CEL language reference for a list of available attributes.
*/
when?: string | null;
}
/**
* Describes properties of one or more sources of a request.
*/
export interface Schema$AuthzPolicyAuthzRuleFrom {
/**
* Optional. Describes the negated properties of request sources. Matches requests from sources that do not match the criteria specified in this field. At least one of sources or notSources must be specified.
*/
notSources?: Schema$AuthzPolicyAuthzRuleFromRequestSource[];
/**
* Optional. Describes the properties of a request's sources. At least one of sources or notSources must be specified. Limited to 1 source. A match occurs when ANY source (in sources or notSources) matches the request. Within a single source, the match follows AND semantics across fields and OR semantics within a single field, i.e. a match occurs when ANY principal matches AND ANY ipBlocks match.
*/
sources?: Schema$AuthzPolicyAuthzRuleFromRequestSource[];
}
/**
* Describes the properties of a single source.
*/
export interface Schema$AuthzPolicyAuthzRuleFromRequestSource {
/**
* Optional. A list of IP addresses or IP address ranges to match against the source IP address of the request. Limited to 10 ip_blocks per Authorization Policy
*/
ipBlocks?: Schema$AuthzPolicyAuthzRuleIpBlock[];
/**
* Optional. A list of identities derived from the client's certificate. This field will not match on a request unless frontend mutual TLS is enabled for the forwarding rule or Gateway and the client certificate has been successfully validated by mTLS. Each identity is a string whose value is matched against a list of URI SANs, DNS Name SANs, or the common name in the client's certificate. A match happens when any principal matches with the rule. Limited to 50 principals per Authorization Policy for Regional Internal Application Load Balancer, Regional External Application Load Balancer, Cross-region Internal Application Load Balancer, and Cloud Service Mesh. Limited to 25 principals per Authorization Policy for Global External Application Load Balancer.
*/
principals?: Schema$AuthzPolicyAuthzRulePrincipal[];
/**
* Optional. A list of resources to match against the resource of the source VM of a request. Limited to 10 resources per Authorization Policy.
*/
resources?: Schema$AuthzPolicyAuthzRuleRequestResource[];
}
/**
* Determines how a HTTP header should be matched.
*/
export interface Schema$AuthzPolicyAuthzRuleHeaderMatch {
/**
* Optional. Specifies the name of the header in the request.
*/
name?: string | null;
/**
* Optional. Specifies how the header match will be performed.
*/
value?: Schema$AuthzPolicyAuthzRuleStringMatch;
}
/**
* Represents a range of IP Addresses.
*/
export interface Schema$AuthzPolicyAuthzRuleIpBlock {
/**
* Required. The length of the address range.
*/
length?: number | null;
/**
* Required. The address prefix.
*/
prefix?: string | null;
}
/**
* Describes the properties of a principal to be matched against.
*/
export interface Schema$AuthzPolicyAuthzRulePrincipal {
/**
* Required. A non-empty string whose value is matched against the principal value based on the principal_selector. Only exact match can be applied for CLIENT_CERT_URI_SAN, CLIENT_CERT_DNS_NAME_SAN, CLIENT_CERT_COMMON_NAME selectors.
*/
principal?: Schema$AuthzPolicyAuthzRuleStringMatch;
/**
* Optional. An enum to decide what principal value the principal rule will match against. If not specified, the PrincipalSelector is CLIENT_CERT_URI_SAN.
*/
principalSelector?: string | null;
}
/**
* Describes the properties of a client VM resource accessing the internal application load balancers.
*/
export interface Schema$AuthzPolicyAuthzRuleRequestResource {
/**
* Optional. An IAM service account to match against the source service account of the VM sending the request.
*/
iamServiceAccount?: Schema$AuthzPolicyAuthzRuleStringMatch;
/**
* Optional. A list of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request.
*/
tagValueIdSet?: Schema$AuthzPolicyAuthzRuleRequestResourceTagValueIdSet;
}
/**
* Describes a set of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request.
*/
export interface Schema$AuthzPolicyAuthzRuleRequestResourceTagValueIdSet {
/**
* Required. A list of resource tag value permanent IDs to match against the resource manager tags value associated with the source VM of a request. The match follows AND semantics which means all the ids must match. Limited to 5 ids in the Tag value id set.
*/
ids?: string[] | null;
}
/**
* Determines how a string value should be matched.
*/
export interface Schema$AuthzPolicyAuthzRuleStringMatch {
/**
* The input string must have the substring specified here. Note: empty contains match is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``xyz.abc.def``
*/
contains?: string | null;
/**
* The input string must match exactly the string specified here. Examples: * ``abc`` only matches the value ``abc``.
*/
exact?: string | null;
/**
* If true, indicates the exact/prefix/suffix/contains matching should be case insensitive. For example, the matcher ``data`` will match both input string ``Data`` and ``data`` if set to true.
*/
ignoreCase?: boolean | null;
/**
* The input string must have the prefix specified here. Note: empty prefix is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``abc.xyz``
*/
prefix?: string | null;
/**
* The input string must have the suffix specified here. Note: empty prefix is not allowed, please use regex instead. Examples: * ``abc`` matches the value ``xyz.abc``
*/
suffix?: string | null;
}
/**
* Describes properties of one or more targets of a request.
*/
export interface Schema$AuthzPolicyAuthzRuleTo {
/**
* Optional. Describes the negated properties of the targets of a request. Matches requests for operations that do not match the criteria specified in this field. At least one of operations or notOperations must be specified.
*/
notOperations?: Schema$AuthzPolicyAuthzRuleToRequestOperation[];
/**
* Optional. Describes properties of one or more targets of a request. At least one of operations or notOperations must be specified. Limited to 1 operation. A match occurs when ANY operation (in operations or notOperations) matches. Within an operation, the match follows AND semantics across fields and OR semantics within a field, i.e. a match occurs when ANY path matches AND ANY header matches and ANY method matches.
*/
operations?: Schema$AuthzPolicyAuthzRuleToRequestOperation[];
}
/**
* Describes properties of one or more targets of a request.
*/
export interface Schema$AuthzPolicyAuthzRuleToRequestOperation {
/**
* Optional. A list of headers to match against in http header.
*/
headerSet?: Schema$AuthzPolicyAuthzRuleToRequestOperationHeaderSet;
/**
* Optional. A list of HTTP Hosts to match against. The match can be one of exact, prefix, suffix, or contains (substring match). Matches are always case sensitive unless the ignoreCase is set. Limited to 10 hosts per Authorization Policy.
*/
hosts?: Schema$AuthzPolicyAuthzRuleStringMatch[];
/**
* Optional. A list of HTTP methods to match against. Each entry must be a valid HTTP method name (GET, PUT, POST, HEAD, PATCH, DELETE, OPTIONS). It only allows exact match and is always case sensitive. Limited to 10 methods per Authorization Policy.
*/
methods?: string[] | null;
/**
* Optional. A list of paths to match against. The match can be one of exact, prefix, suffix, or contains (substring match). Matches are always case sensitive unless the ignoreCase is set. Limited to 10 paths per Authorization Policy. Note that this path match includes the query parameters. For gRPC services, this should be a fully-qualified name of the form /package.service/method.
*/
paths?: Schema$AuthzPolicyAuthzRuleStringMatch[];
}
/**
* Describes a set of HTTP headers to match against.
*/
export interface Schema$AuthzPolicyAuthzRuleToRequestOperationHeaderSet {
/**
* Required. A list of headers to match against in http header. The match can be one of exact, prefix, suffix, or contains (substring match). The match follows AND semantics which means all the headers must match. Matches are always case sensitive unless the ignoreCase is set. Limited to 10 headers per Authorization Policy.
*/
headers?: Schema$AuthzPolicyAuthzRuleHeaderMatch[];
}
/**
* Allows delegating authorization decisions to Cloud IAP or to Service Extensions.
*/
export interface Schema$AuthzPolicyCustomProvider {
/**
* Optional. Delegate authorization decision to user authored Service Extension. Only one of cloudIap or authzExtension can be specified.
*/
authzExtension?: Schema$AuthzPolicyCustomProviderAuthzExtension;
/**
* Optional. Delegates authorization decisions to Cloud IAP. Applicable only for managed load balancers. Enabling Cloud IAP at the AuthzPolicy level is not compatible with Cloud IAP settings in the BackendService. Enabling IAP in both places will result in request failure. Ensure that IAP is enabled in either the AuthzPolicy or the BackendService but not in both places.
*/
cloudIap?: Schema$AuthzPolicyCustomProviderCloudIap;
}
/**
* Optional. Delegate authorization decision to user authored extension. Only one of cloudIap or authzExtension can be specified.
*/
export interface Schema$AuthzPolicyCustomProviderAuthzExtension {
/**
* Required. A list of references to authorization extensions that will be invoked for requests matching this policy. Limited to 1 custom provider.
*/
resources?: string[] | null;
}
/**
* Optional. Delegates authorization decisions to Cloud IAP. Applicable only for managed load balancers. Enabling Cloud IAP at the AuthzPolicy level is not compatible with Cloud IAP settings in the BackendService. Enabling IAP in both places will result in request failure. Ensure that IAP is enabled in either the AuthzPolicy or the BackendService but not in both places.
*/
export interface Schema$AuthzPolicyCustomProviderCloudIap {
}
/**
* Specifies the set of targets to which this policy should be applied to.
*/
export interface Schema$AuthzPolicyTarget {
/**
* Required. All gateways and forwarding rules referenced by this policy and extensions must share the same load balancing scheme. Supported values: `INTERNAL_MANAGED` and `EXTERNAL_MANAGED`. For more information, refer to [Backend services overview](https://cloud.google.com/load-balancing/docs/backend-service).
*/
loadBalancingScheme?: string | null;
/**
* Required. A list of references to the Forwarding Rules on which this policy will be applied.
*/
resources?: string[] | null;
}
/**
* BackendAuthenticationConfig message groups the TrustConfig together with other settings that control how the load balancer authenticates, and expresses its identity to, the backend: * `trustConfig` is the attached TrustConfig. * `wellKnownRoots` indicates whether the load balance should trust backend server certificates that are issued by public certificate authorities, in addition to certificates trusted by the TrustConfig. * `clientCertificate` is a client certificate that the load balancer uses to express its identity to the backend, if the connection to the backend uses mTLS. You can attach the BackendAuthenticationConfig to the load balancer's BackendService directly determining how that BackendService negotiates TLS.
*/
export interface Schema$BackendAuthenticationConfig {
/**
* Optional. A reference to a certificatemanager.googleapis.com.Certificate resource. This is a relative resource path following the form "projects/{project\}/locations/{location\}/certificates/{certificate\}". Used by a BackendService to negotiate mTLS when the backend connection uses TLS and the backend requests a client certificate. Must have a CLIENT_AUTH scope.
*/
clientCertificate?: string | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Output only. Etag of the resource.
*/
etag?: string | null;
/**
* Set of label tags associated with the resource.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. Name of the BackendAuthenticationConfig resource. It matches the pattern `projects/x/locations/{location\}/backendAuthenticationConfigs/{backend_authentication_config\}`
*/
name?: string | null;
/**
* Optional. A reference to a TrustConfig resource from the certificatemanager.googleapis.com namespace. This is a relative resource path following the form "projects/{project\}/locations/{location\}/trustConfigs/{trust_config\}". A BackendService uses the chain of trust represented by this TrustConfig, if specified, to validate the server certificates presented by the backend. Required unless wellKnownRoots is set to PUBLIC_ROOTS.
*/
trustConfig?: string | null;
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
/**
* Well known roots to use for server certificate validation.
*/
wellKnownRoots?: string | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Specification of a TLS certificate provider instance. Workloads may have one or more CertificateProvider instances (plugins) and one of them is enabled and configured by specifying this message. Workloads use the values from this message to locate and load the CertificateProvider instance configuration.
*/
export interface Schema$CertificateProviderInstance {
/**
* Required. Plugin instance name, used to locate and load CertificateProvider instance configuration. Set to "google_cloud_private_spiffe" to use Certificate Authority Service certificate provider instance.
*/
pluginInstance?: string | null;
}
/**
* ClientTlsPolicy is a resource that specifies how a client should authenticate connections to backends of a service. This resource itself does not affect configuration unless it is attached to a backend service resource.
*/
export interface Schema$ClientTlsPolicy {
/**
* Optional. Defines a mechanism to provision client identity (public and private keys) for peer to peer authentication. The presence of this dictates mTLS.
*/
clientCertificate?: Schema$GoogleCloudNetworksecurityV1CertificateProvider;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Optional. Set of label tags associated with the resource.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Required. Name of the ClientTlsPolicy resource. It matches the pattern `projects/{project\}/locations/{location\}/clientTlsPolicies/{client_tls_policy\}`
*/
name?: string | null;
/**
* Optional. Defines the mechanism to obtain the Certificate Authority certificate to validate the server certificate. If empty, client does not validate the server certificate.
*/
serverValidationCa?: Schema$ValidationCA[];
/**
* Optional. Server Name Indication string to present to the server during TLS handshake. E.g: "secure.example.com".
*/
sni?: string | null;
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
}
/**
* Request used by the CloneAddressGroupItems method.
*/
export interface Schema$CloneAddressGroupItemsRequest {
/**
* Optional. An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000).
*/
requestId?: string | null;
/**
* Required. Source address group to clone items from.
*/
sourceAddressGroup?: string | null;
}
/**
* CustomInterceptProfile defines in-band integration behavior (intercept). It is used by firewall rules with an APPLY_SECURITY_PROFILE_GROUP action.
*/
export interface Schema$CustomInterceptProfile {
/**
* Required. The target InterceptEndpointGroup. When a firewall rule with this security profile attached matches a packet, the packet will be intercepted to the location-local target in this group.
*/
interceptEndpointGroup?: string | null;
}
/**
* CustomMirroringProfile defines out-of-band integration behavior (mirroring). It is used by mirroring rules with a MIRROR action.
*/
export interface Schema$CustomMirroringProfile {
/**
* Required. The target MirroringEndpointGroup. When a mirroring rule with this security profile attached matches a packet, a replica will be mirrored to the location-local target in this group.
*/
mirroringEndpointGroup?: string | null;
}
/**
* Specification of traffic destination attributes.
*/
export interface Schema$Destination {
/**
* Required. List of host names to match. Matched against the ":authority" header in http requests. At least one host should match. Each host can be an exact match, or a prefix match (example "mydomain.*") or a suffix match (example "*.myorg.com") or a presence (any) match "*".
*/
hosts?: string[] | null;
/**
* Optional. Match against key:value pair in http header. Provides a flexible match based on HTTP headers, for potentially advanced use cases. At least one header should match. Avoid using header matches to make authorization decisions unless there is a strong guarantee that requests arrive through a trusted client or proxy.
*/
httpHeaderMatch?: Schema$HttpHeaderMatch;
/**
* Optional. A list of HTTP methods to match. At least one method should match. Should not be set for gRPC services.
*/
methods?: string[] | null;
/**
* Required. List of destination ports to match. At least one port should match.
*/
ports?: number[] | null;
}
/**
* 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); \}
*/
export interface Schema$Empty {
}
/**
* Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
*/
export interface Schema$Expr {
/**
* Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
*/
description?: string | null;
/**
* Textual representation of an expression in Common Expression Language syntax.
*/
expression?: string | null;
/**
* Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
*/
location?: string | null;
/**
* Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
*/
title?: string | null;
}
/**
* Message describing Endpoint object
*/
export interface Schema$FirewallEndpoint {
/**
* Output only. List of networks that are associated with this endpoint in the local zone. This is a projection of the FirewallEndpointAssociations pointing at this endpoint. A network will only appear in this list after traffic routing is fully configured. Format: projects/{project\}/global/networks/{name\}.
*/
associatedNetworks?: string[] | null;
/**
* Output only. List of FirewallEndpointAssociations that are associated to this endpoint. An association will only appear in this list after traffic routing is fully configured.
*/
associations?: Schema$FirewallEndpointAssociationReference[];
/**
* Required. Project to bill on endpoint uptime usage.
*/
billingProjectId?: string | null;
/**
* Output only. Create time stamp
*/
createTime?: string | null;
/**
* Optional. Description of the firewall endpoint. Max length 2048 characters.
*/
description?: string | null;
/**
* Optional. Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Immutable. Identifier. name of resource
*/
name?: string | null;
/**
* Output only. Whether reconciling is in progress, recommended per https://google.aip.dev/128.
*/
reconciling?: boolean | null;
/**
* Output only. [Output Only] Reserved for future use.
*/
satisfiesPzi?: boolean | null;
/**
* Output only. [Output Only] Reserved for future use.
*/
satisfiesPzs?: boolean | null;
/**
* Output only. Current state of the endpoint.
*/
state?: string | null;
/**
* Output only. Update time stamp
*/
updateTime?: string | null;
}
/**
* Message describing Association object
*/
export interface Schema$FirewallEndpointAssociation {
/**
* Output only. Create time stamp
*/
createTime?: string | null;
/**
* Optional. Whether the association is disabled. True indicates that traffic won't be intercepted
*/
disabled?: boolean | null;
/**
* Required. The URL of the FirewallEndpoint that is being associated.
*/
firewallEndpoint?: string | null;
/**
* Optional. Labels as key value pairs
*/
labels?: {
[key: string]: string;
} | null;
/**
* Immutable. Identifier. name of resource
*/
name?: string | null;
/**
* Required. The URL of the network that is being associated.
*/
network?: string | null;
/**
* Output only. Whether reconciling is in progress, recommended per https://google.aip.dev/128.
*/
reconciling?: boolean | null;
/**
* Output only. Current state of the association.
*/
state?: string | null;
/**
* Optional. The URL of the TlsInspectionPolicy that is being associated.
*/
tlsInspectionPolicy?: string | null;
/**
* Output only. Update time stamp
*/
updateTime?: string | null;
}
/**
* This is a subset of the FirewallEndpointAssociation message, containing fields to be used by the consumer.
*/
export interface Schema$FirewallEndpointAssociationReference {
/**
* Output only. The resource name of the FirewallEndpointAssociation. Format: projects/{project\}/locations/{location\}/firewallEndpointAssociations/{id\}
*/
name?: string | null;
/**
* Output only. The VPC network associated. Format: projects/{project\}/global/networks/{name\}.
*/
network?: string | null;
}
/**
* The GatewaySecurityPolicy resource contains a collection of GatewaySecurityPolicyRules and associated metadata.
*/
export interface Schema$GatewaySecurityPolicy {
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Required. Name of the resource. Name is of the form projects/{project\}/locations/{location\}/gatewaySecurityPolicies/{gateway_security_policy\} gateway_security_policy should match the pattern:(^[a-z]([a-z0-9-]{0,61\}[a-z0-9])?$).
*/
name?: string | null;
/**
* Optional. Name of a TLS Inspection Policy resource that defines how TLS inspection will be performed for any rule(s) which enables it.
*/
tlsInspectionPolicy?: string | null;
/**
* Output only. The timestamp when the resource was updated.
*/
updateTime?: string | null;
}
/**
* The GatewaySecurityPolicyRule resource is in a nested collection within a GatewaySecurityPolicy and represents a traffic matching condition and associated action to perform.
*/
export interface Schema$GatewaySecurityPolicyRule {
/**
* Optional. CEL expression for matching on L7/application level criteria.
*/
applicationMatcher?: string | null;
/**
* Required. Profile which tells what the primitive action should be.
*/
basicProfile?: string | null;
/**
* Output only. Time when the rule was created.
*/
createTime?: string | null;
/**
* Optional. Free-text description of the resource.
*/
description?: string | null;
/**
* Required. Whether the rule is enforced.
*/
enabled?: boolean | null;
/**
* Required. Immutable. Name of the resource. ame is the full resource name so projects/{project\}/locations/{location\}/gatewaySecurityPolicies/{gateway_security_policy\}/rules/{rule\} rule should match the pattern: (^[a-z]([a-z0-9-]{0,61\}[a-z0-9])?$).
*/
name?: string | null;
/**
* Required. Priority of the rule. Lower number corresponds to higher precedence.
*/
priority?: number | null;
/**
* Required. CEL expression for matching on session criteria.
*/
sessionMatcher?: string | null;
/**
* Optional. Flag to enable TLS inspection of traffic matching on , can only be true if the parent GatewaySecurityPolicy references a TLSInspectionConfig.
*/
tlsInspectionEnabled?: boolean | null;
/**
* Output only. Time when the rule was updated.
*/
updateTime?: string | null;
}
/**
* Specification of certificate provider. Defines the mechanism to obtain the certificate and private key for peer to peer authentication.
*/
export interface Schema$GoogleCloudNetworksecurityV1CertificateProvider {
/**
* The certificate provider instance specification that will be passed to the data plane, which will be used to load necessary credential information.
*/
certificateProviderInstance?: Schema$CertificateProviderInstance;
/**
* gRPC specific configuration to access the gRPC server to obtain the cert and private key.
*/
grpcEndpoint?: Schema$GoogleCloudNetworksecurityV1GrpcEndpoint;
}
/**
* Specification of the GRPC Endpoint.
*/
export interface Schema$GoogleCloudNetworksecurityV1GrpcEndpoint {
/**
* Required. The target URI of the gRPC endpoint. Only UDS path is supported, and should start with "unix:".
*/
targetUri?: string | null;
}
/**
* Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] \}, { "log_type": "DATA_WRITE" \}, { "log_type": "ADMIN_READ" \} ] \}, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" \}, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] \} ] \} ] \} For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` from DATA_WRITE logging.
*/
export interface Schema$GoogleIamV1AuditConfig {
/**
* The configuration for logging of each type of permission.
*/
auditLogConfigs?: Schema$GoogleIamV1AuditLogConfig[];
/**
* Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
*/
service?: string | null;
}
/**
* Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] \}, { "log_type": "DATA_WRITE" \} ] \} This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.
*/
export interface Schema$GoogleIamV1AuditLogConfig {
/**
* Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
*/
exemptedMembers?: string[] | null;
/**
* The log type that this config enables.
*/
logType?: string | null;
}
/**
* Associates `members`, or principals, with a `role`.
*/
export interface Schema$GoogleIamV1Binding {
/**
* The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the principals in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
*/
condition?: Schema$Expr;
/**
* Specifies the principals requesting access for a Google Cloud resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. Does not include identities that come from external identity providers (IdPs) through identity federation. * `user:{emailid\}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid\}`: An email address that represents a Google service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `serviceAccount:{projectid\}.svc.id.goog[{namespace\}/{kubernetes-sa\}]`: An identifier for a [Kubernetes service account](https://cloud.google.com/kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my-project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:{emailid\}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain\}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`. * `principal://iam.googleapis.com/locations/global/workforcePools/{pool_id\}/subject/{subject_attribute_value\}`: A single identity in a workforce identity pool. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id\}/group/{group_id\}`: All workforce identities in a group. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id\}/attribute.{attribute_name\}/{attribute_value\}`: All workforce identities with a specific attribute value. * `principalSet://iam.googleapis.com/locations/global/workforcePools/{pool_id\}/x`: All identities in a workforce identity pool. * `principal://iam.googleapis.com/projects/{project_number\}/locations/global/workloadIdentityPools/{pool_id\}/subject/{subject_attribute_value\}`: A single identity in a workload identity pool. * `principalSet://iam.googleapis.com/projects/{project_number\}/locations/global/workloadIdentityPools/{pool_id\}/group/{group_id\}`: A workload identity pool group. * `principalSet://iam.googleapis.com/projects/{project_number\}/locations/global/workloadIdentityPools/{pool_id\}/attribute.{attribute_name\}/{attribute_value\}`: All identities in a workload identity pool with a certain attribute. * `principalSet://iam.googleapis.com/projects/{project_number\}/locations/global/workloadIdentityPools/{pool_id\}/x`: All identities in a workload identity pool. * `deleted:user:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid\}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid\}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid\}?uid={uniqueid\}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid\}` and the recovered group retains the role in the binding. * `deleted:principal://iam.googleapis.com/locations/global/workforcePools/{pool_id\}/subject/{subject_attribute_value\}`: Deleted single identity in a workforce identity pool. For example, `deleted:principal://iam.googleapis.com/locations/global/workforcePools/my-pool-id/subject/my-subject-attribute-value`.
*/
members?: string[] | null;
/**
* Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. For an overview of the IAM roles and permissions, see the [IAM documentation](https://cloud.google.com/iam/docs/roles-overview). For a list of the available pre-defined roles, see [here](https://cloud.google.com/iam/docs/understanding-roles).
*/
role?: string | null;
}
/**
* An Identity and Access Management (IAM) policy, which specifies access controls for Google Cloud resources. A `Policy` is a collection of `bindings`. A `binding` binds one or more `members`, or principals, to a single `role`. Principals can be user accounts, service accounts, Google groups, and domains (such as G Suite). A `role` is a named list of permissions; each `role` can be an IAM predefined role or a user-created custom role. For some types of Google Cloud resources, a `binding` can also specify a `condition`, which is a logical expression that allows access to a resource only if the expression evaluates to `true`. A condition can add constraints based on attributes of the request, the resource, or both. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies). **JSON example:** ``` { "bindings": [ { "role": "roles/resourcemanager.organizationAdmin", "members": [ "user:mike@example.com", "group:admins@example.com", "do