@maxim_mazurok/gapi.client.cloudasset-v1p7beta1 0.0.20220805

package/index.d.ts

@@ -0,0 +1,776 @@
+/* Type definitions for non-npm package Cloud Asset API v1p7beta1 0.0 */
+// Project: https://cloud.google.com/asset-inventory/docs/quickstart
+// Definitions by: Maxim Mazurok <https://github.com/Maxim-Mazurok>
+//                 Nick Amoscato <https://github.com/namoscato>
+//                 Declan Vong <https://github.com/declanvong>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+// IMPORTANT
+// This file was generated by https://github.com/Maxim-Mazurok/google-api-typings-generator. Please do not edit it manually.
+// In case of any problems please post issue to https://github.com/Maxim-Mazurok/google-api-typings-generator
+// Generated from: https://cloudasset.googleapis.com/$discovery/rest?version=v1p7beta1
+// Revision: 20220805
+
+/// <reference types="gapi.client" />
+
+declare namespace gapi.client {
+    /** Load Cloud Asset API v1p7beta1 */
+    function load(urlOrObject: "https://cloudasset.googleapis.com/$discovery/rest?version=v1p7beta1"): Promise<void>;
+    /** @deprecated Please load APIs with discovery documents. */
+    function load(name: "cloudasset", version: "v1p7beta1"): Promise<void>;
+    /** @deprecated Please load APIs with discovery documents. */
+    function load(name: "cloudasset", version: "v1p7beta1", callback: () => any): void;
+
+    namespace cloudasset {
+        interface AnalyzeIamPolicyLongrunningMetadata {
+            /** Output only. The time the operation was created. */
+            createTime?: string;
+        }
+        // tslint:disable-next-line:no-empty-interface
+        interface AnalyzeIamPolicyLongrunningResponse {
+        }
+        interface AuditConfig {
+            /** The configuration for logging of each type of permission. */
+            auditLogConfigs?: AuditLogConfig[];
+            /**
+             * 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;
+        }
+        interface AuditLogConfig {
+            /** Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members. */
+            exemptedMembers?: string[];
+            /** The log type that this config enables. */
+            logType?: string;
+        }
+        interface Binding {
+            /**
+             * 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?: 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. * `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`. *
+             * `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. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
+             */
+            members?: string[];
+            /** Role that is assigned to the list of `members`, or principals. For example, `roles/viewer`, `roles/editor`, or `roles/owner`. */
+            role?: string;
+        }
+        interface 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;
+            /** Textual representation of an expression in Common Expression Language syntax. */
+            expression?: string;
+            /** Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file. */
+            location?: string;
+            /** 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;
+        }
+        interface GoogleCloudAssetV1p7beta1Asset {
+            /** Please also refer to the [access level user guide](https://cloud.google.com/access-context-manager/docs/overview#access-levels). */
+            accessLevel?: GoogleIdentityAccesscontextmanagerV1AccessLevel;
+            /** Please also refer to the [access policy user guide](https://cloud.google.com/access-context-manager/docs/overview#access-policies). */
+            accessPolicy?: GoogleIdentityAccesscontextmanagerV1AccessPolicy;
+            /**
+             * The ancestry path of an asset in Google Cloud [resource hierarchy](https://cloud.google.com/resource-manager/docs/cloud-platform-resource-hierarchy), represented as a list of
+             * relative resource names. An ancestry path starts with the closest ancestor in the hierarchy and ends at root. If the asset is a project, folder, or organization, the ancestry path
+             * starts from the asset itself. Example: `["projects/123456789", "folders/5432", "organizations/1234"]`
+             */
+            ancestors?: string[];
+            /** The type of the asset. Example: `compute.googleapis.com/Disk` See [Supported asset types](https://cloud.google.com/asset-inventory/docs/supported-asset-types) for more information. */
+            assetType?: string;
+            /**
+             * A representation of the Cloud IAM policy set on a Google Cloud resource. There can be a maximum of one Cloud IAM policy set on any given resource. In addition, Cloud IAM policies
+             * inherit their granted access scope from any policies set on parent resources in the resource hierarchy. Therefore, the effectively policy is the union of both the policy set on this
+             * resource and each policy set on all of the resource's ancestry resource levels in the hierarchy. See [this topic](https://cloud.google.com/iam/help/allow-policies/inheritance) for
+             * more information.
+             */
+            iamPolicy?: Policy;
+            /**
+             * The full name of the asset. Example: `//compute.googleapis.com/projects/my_project_123/zones/zone1/instances/instance1` See [Resource
+             * names](https://cloud.google.com/apis/design/resource_names#full_resource_name) for more information.
+             */
+            name?: string;
+            /**
+             * A representation of an [organization policy](https://cloud.google.com/resource-manager/docs/organization-policy/overview#organization_policy). There can be more than one
+             * organization policy with different constraints set on a given resource.
+             */
+            orgPolicy?: GoogleCloudOrgpolicyV1Policy[];
+            /** The related assets of the asset of one relationship type. One asset only represents one type of relationship. */
+            relatedAssets?: GoogleCloudAssetV1p7beta1RelatedAssets;
+            /** A representation of the resource. */
+            resource?: GoogleCloudAssetV1p7beta1Resource;
+            /** Please also refer to the [service perimeter user guide](https://cloud.google.com/vpc-service-controls/docs/overview). */
+            servicePerimeter?: GoogleIdentityAccesscontextmanagerV1ServicePerimeter;
+            /** The last update timestamp of an asset. update_time is updated when create/update/delete operation is performed. */
+            updateTime?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1BigQueryDestination {
+            /**
+             * Required. The BigQuery dataset in format "projects/projectId/datasets/datasetId", to which the snapshot result should be exported. If this dataset does not exist, the export call
+             * returns an INVALID_ARGUMENT error.
+             */
+            dataset?: string;
+            /**
+             * If the destination table already exists and this flag is `TRUE`, the table will be overwritten by the contents of assets snapshot. If the flag is `FALSE` or unset and the
+             * destination table already exists, the export call returns an INVALID_ARGUMEMT error.
+             */
+            force?: boolean;
+            /**
+             * [partition_spec] determines whether to export to partitioned table(s) and how to partition the data. If [partition_spec] is unset or [partition_spec.partition_key] is unset or
+             * `PARTITION_KEY_UNSPECIFIED`, the snapshot results will be exported to non-partitioned table(s). [force] will decide whether to overwrite existing table(s). If [partition_spec] is
+             * specified. First, the snapshot results will be written to partitioned table(s) with two additional timestamp columns, readTime and requestTime, one of which will be the partition
+             * key. Secondly, in the case when any destination table already exists, it will first try to update existing table's schema as necessary by appending additional columns. Then, if
+             * [force] is `TRUE`, the corresponding partition will be overwritten by the snapshot results (data in different partitions will remain intact); if [force] is unset or `FALSE`, it will
+             * append the data. An error will be returned if the schema update or data appension fails.
+             */
+            partitionSpec?: GoogleCloudAssetV1p7beta1PartitionSpec;
+            /**
+             * If this flag is `TRUE`, the snapshot results will be written to one or multiple tables, each of which contains results of one asset type. The [force] and [partition_spec] fields
+             * will apply to each of them. Field [table] will be concatenated with "_" and the asset type names (see https://cloud.google.com/asset-inventory/docs/supported-asset-types for
+             * supported asset types) to construct per-asset-type table names, in which all non-alphanumeric characters like "." and "/" will be substituted by "_". Example: if field [table] is
+             * "mytable" and snapshot results contain "storage.googleapis.com/Bucket" assets, the corresponding table name will be "mytable_storage_googleapis_com_Bucket". If any of these tables
+             * does not exist, a new table with the concatenated name will be created. When [content_type] in the ExportAssetsRequest is `RESOURCE`, the schema of each table will include
+             * RECORD-type columns mapped to the nested fields in the Asset.resource.data field of that asset type (up to the 15 nested level BigQuery supports
+             * (https://cloud.google.com/bigquery/docs/nested-repeated#limitations)). The fields in >15 nested levels will be stored in JSON format string as a child column of its parent RECORD
+             * column. If error occurs when exporting to any table, the whole export call will return an error but the export results that already succeed will persist. Example: if exporting to
+             * table_type_A succeeds when exporting to table_type_B fails during one export call, the results in table_type_A will persist and there will not be partial results persisting in a
+             * table.
+             */
+            separateTablesPerAssetType?: boolean;
+            /** Required. The BigQuery table to which the snapshot result should be written. If this table does not exist, a new table with the given name will be created. */
+            table?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1ExportAssetsRequest {
+            /**
+             * A list of asset types to take a snapshot for. For example: "compute.googleapis.com/Disk". Regular expressions are also supported. For example: * "compute.googleapis.com.*" snapshots
+             * resources whose asset type starts with "compute.googleapis.com". * ".*Instance" snapshots resources whose asset type ends with "Instance". * ".*Instance.*" snapshots resources whose
+             * asset type contains "Instance". See [RE2](https://github.com/google/re2/wiki/Syntax) for all supported regular expression syntax. If the regular expression does not match any
+             * supported asset type, an INVALID_ARGUMENT error will be returned. If specified, only matching assets will be returned, otherwise, it will snapshot all asset types. See [Introduction
+             * to Cloud Asset Inventory](https://cloud.google.com/asset-inventory/docs/overview) for all supported asset types.
+             */
+            assetTypes?: string[];
+            /** Asset content type. If not specified, no content but the asset name will be returned. */
+            contentType?: string;
+            /** Required. Output configuration indicating where the results will be output to. */
+            outputConfig?: GoogleCloudAssetV1p7beta1OutputConfig;
+            /**
+             * Timestamp to take an asset snapshot. This can only be set to a timestamp between the current time and the current time minus 35 days (inclusive). If not specified, the current time
+             * will be used. Due to delays in resource data collection and indexing, there is a volatile window during which running the same query may get different results.
+             */
+            readTime?: string;
+            /**
+             * A list of relationship types to export, for example: `INSTANCE_TO_INSTANCEGROUP`. This field should only be specified if content_type=RELATIONSHIP. If specified, it will snapshot
+             * [asset_types]' specified relationships, or give errors if any relationship_types' supported types are not in [asset_types]. If not specified, it will snapshot all [asset_types]'
+             * supported relationships. An unspecified [asset_types] field means all supported asset_types. See [Introduction to Cloud Asset
+             * Inventory](https://cloud.google.com/asset-inventory/docs/overview) for all supported asset types and relationship types.
+             */
+            relationshipTypes?: string[];
+        }
+        interface GoogleCloudAssetV1p7beta1GcsDestination {
+            /**
+             * The uri of the Cloud Storage object. It's the same uri that is used by gsutil. Example: "gs://bucket_name/object_name". See [Viewing and Editing Object
+             * Metadata](https://cloud.google.com/storage/docs/viewing-editing-metadata) for more information.
+             */
+            uri?: string;
+            /**
+             * The uri prefix of all generated Cloud Storage objects. Example: "gs://bucket_name/object_name_prefix". Each object uri is in format:
+             * "gs://bucket_name/object_name_prefix/{ASSET_TYPE}/{SHARD_NUMBER} and only contains assets for that type. starts from 0. Example:
+             * "gs://bucket_name/object_name_prefix/compute.googleapis.com/Disk/0" is the first shard of output objects containing all compute.googleapis.com/Disk assets. An INVALID_ARGUMENT error
+             * will be returned if file with the same name "gs://bucket_name/object_name_prefix" already exists.
+             */
+            uriPrefix?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1OutputConfig {
+            /** Destination on BigQuery. The output table stores the fields in asset proto as columns in BigQuery. */
+            bigqueryDestination?: GoogleCloudAssetV1p7beta1BigQueryDestination;
+            /** Destination on Cloud Storage. */
+            gcsDestination?: GoogleCloudAssetV1p7beta1GcsDestination;
+        }
+        interface GoogleCloudAssetV1p7beta1PartitionSpec {
+            /** The partition key for BigQuery partitioned table. */
+            partitionKey?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1RelatedAsset {
+            /**
+             * The ancestors of an asset in Google Cloud [resource hierarchy](https://cloud.google.com/resource-manager/docs/cloud-platform-resource-hierarchy), represented as a list of relative
+             * resource names. An ancestry path starts with the closest ancestor in the hierarchy and ends at root. Example: `["projects/123456789", "folders/5432", "organizations/1234"]`
+             */
+            ancestors?: string[];
+            /**
+             * The full name of the asset. Example: `//compute.googleapis.com/projects/my_project_123/zones/zone1/instances/instance1` See [Resource
+             * names](https://cloud.google.com/apis/design/resource_names#full_resource_name) for more information.
+             */
+            asset?: string;
+            /** The type of the asset. Example: `compute.googleapis.com/Disk` See [Supported asset types](https://cloud.google.com/asset-inventory/docs/supported-asset-types) for more information. */
+            assetType?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1RelatedAssets {
+            /** The peer resources of the relationship. */
+            assets?: GoogleCloudAssetV1p7beta1RelatedAsset[];
+            /** The detailed relation attributes. */
+            relationshipAttributes?: GoogleCloudAssetV1p7beta1RelationshipAttributes;
+        }
+        interface GoogleCloudAssetV1p7beta1RelationshipAttributes {
+            /** The detail of the relationship, e.g. `contains`, `attaches` */
+            action?: string;
+            /** The source asset type. Example: `compute.googleapis.com/Instance` */
+            sourceResourceType?: string;
+            /** The target asset type. Example: `compute.googleapis.com/Disk` */
+            targetResourceType?: string;
+            /** The unique identifier of the relationship type. Example: `INSTANCE_TO_INSTANCEGROUP` */
+            type?: string;
+        }
+        interface GoogleCloudAssetV1p7beta1Resource {
+            /** The content of the resource, in which some sensitive fields are removed and may not be present. */
+            data?: { [P in string]: any };
+            /**
+             * The URL of the discovery document containing the resource's JSON schema. Example: `https://www.googleapis.com/discovery/v1/apis/compute/v1/rest` This value is unspecified for
+             * resources that do not have an API based on a discovery document, such as Cloud Bigtable.
+             */
+            discoveryDocumentUri?: string;
+            /**
+             * The JSON schema name listed in the discovery document. Example: `Project` This value is unspecified for resources that do not have an API based on a discovery document, such as
+             * Cloud Bigtable.
+             */
+            discoveryName?: string;
+            /** The location of the resource in Google Cloud, such as its zone and region. For more information, see https://cloud.google.com/about/locations/. */
+            location?: string;
+            /**
+             * The full name of the immediate parent of this resource. See [Resource Names](https://cloud.google.com/apis/design/resource_names#full_resource_name) for more information. For Google
+             * Cloud assets, this value is the parent resource defined in the [Cloud IAM policy hierarchy](https://cloud.google.com/iam/docs/overview#policy_hierarchy). Example:
+             * `//cloudresourcemanager.googleapis.com/projects/my_project_123` For third-party assets, this field may be set differently.
+             */
+            parent?: string;
+            /**
+             * The REST URL for accessing the resource. An HTTP `GET` request using this URL returns the resource itself. Example:
+             * `https://cloudresourcemanager.googleapis.com/v1/projects/my-project-123` This value is unspecified for resources without a REST API.
+             */
+            resourceUrl?: string;
+            /** The API version. Example: `v1` */
+            version?: string;
+        }
+        interface GoogleCloudOrgpolicyV1BooleanPolicy {
+            /**
+             * If `true`, then the `Policy` is enforced. If `false`, then any configuration is acceptable. Suppose you have a `Constraint` `constraints/compute.disableSerialPortAccess` with
+             * `constraint_default` set to `ALLOW`. A `Policy` for that `Constraint` exhibits the following behavior: - If the `Policy` at this resource has enforced set to `false`, serial port
+             * connection attempts will be allowed. - If the `Policy` at this resource has enforced set to `true`, serial port connection attempts will be refused. - If the `Policy` at this
+             * resource is `RestoreDefault`, serial port connection attempts will be allowed. - If no `Policy` is set at this resource or anywhere higher in the resource hierarchy, serial port
+             * connection attempts will be allowed. - If no `Policy` is set at this resource, but one exists higher in the resource hierarchy, the behavior is as if the`Policy` were set at this
+             * resource. The following examples demonstrate the different possible layerings: Example 1 (nearest `Constraint` wins): `organizations/foo` has a `Policy` with: {enforced: false}
+             * `projects/bar` has no `Policy` set. The constraint at `projects/bar` and `organizations/foo` will not be enforced. Example 2 (enforcement gets replaced): `organizations/foo` has a
+             * `Policy` with: {enforced: false} `projects/bar` has a `Policy` with: {enforced: true} The constraint at `organizations/foo` is not enforced. The constraint at `projects/bar` is
+             * enforced. Example 3 (RestoreDefault): `organizations/foo` has a `Policy` with: {enforced: true} `projects/bar` has a `Policy` with: {RestoreDefault: {}} The constraint at
+             * `organizations/foo` is enforced. The constraint at `projects/bar` is not enforced, because `constraint_default` for the `Constraint` is `ALLOW`.
+             */
+            enforced?: boolean;
+        }
+        interface GoogleCloudOrgpolicyV1ListPolicy {
+            /** List of values allowed at this resource. Can only be set if `all_values` is set to `ALL_VALUES_UNSPECIFIED`. */
+            allowedValues?: string[];
+            /** The policy all_values state. */
+            allValues?: string;
+            /** List of values denied at this resource. Can only be set if `all_values` is set to `ALL_VALUES_UNSPECIFIED`. */
+            deniedValues?: string[];
+            /**
+             * Determines the inheritance behavior for this `Policy`. By default, a `ListPolicy` set at a resource supersedes any `Policy` set anywhere up the resource hierarchy. However, if
+             * `inherit_from_parent` is set to `true`, then the values from the effective `Policy` of the parent resource are inherited, meaning the values set in this `Policy` are added to the
+             * values inherited up the hierarchy. Setting `Policy` hierarchies that inherit both allowed values and denied values isn't recommended in most circumstances to keep the configuration
+             * simple and understandable. However, it is possible to set a `Policy` with `allowed_values` set that inherits a `Policy` with `denied_values` set. In this case, the values that are
+             * allowed must be in `allowed_values` and not present in `denied_values`. For example, suppose you have a `Constraint` `constraints/serviceuser.services`, which has a
+             * `constraint_type` of `list_constraint`, and with `constraint_default` set to `ALLOW`. Suppose that at the Organization level, a `Policy` is applied that restricts the allowed API
+             * activations to {`E1`, `E2`}. Then, if a `Policy` is applied to a project below the Organization that has `inherit_from_parent` set to `false` and field all_values set to DENY, then
+             * an attempt to activate any API will be denied. The following examples demonstrate different possible layerings for `projects/bar` parented by `organizations/foo`: Example 1 (no
+             * inherited values): `organizations/foo` has a `Policy` with values: {allowed_values: "E1" allowed_values:"E2"} `projects/bar` has `inherit_from_parent` `false` and values:
+             * {allowed_values: "E3" allowed_values: "E4"} The accepted values at `organizations/foo` are `E1`, `E2`. The accepted values at `projects/bar` are `E3`, and `E4`. Example 2 (inherited
+             * values): `organizations/foo` has a `Policy` with values: {allowed_values: "E1" allowed_values:"E2"} `projects/bar` has a `Policy` with values: {value: "E3" value: "E4"
+             * inherit_from_parent: true} The accepted values at `organizations/foo` are `E1`, `E2`. The accepted values at `projects/bar` are `E1`, `E2`, `E3`, and `E4`. Example 3 (inheriting
+             * both allowed and denied values): `organizations/foo` has a `Policy` with values: {allowed_values: "E1" allowed_values: "E2"} `projects/bar` has a `Policy` with: {denied_values:
+             * "E1"} The accepted values at `organizations/foo` are `E1`, `E2`. The value accepted at `projects/bar` is `E2`. Example 4 (RestoreDefault): `organizations/foo` has a `Policy` with
+             * values: {allowed_values: "E1" allowed_values:"E2"} `projects/bar` has a `Policy` with values: {RestoreDefault: {}} The accepted values at `organizations/foo` are `E1`, `E2`. The
+             * accepted values at `projects/bar` are either all or none depending on the value of `constraint_default` (if `ALLOW`, all; if `DENY`, none). Example 5 (no policy inherits parent
+             * policy): `organizations/foo` has no `Policy` set. `projects/bar` has no `Policy` set. The accepted values at both levels are either all or none depending on the value of
+             * `constraint_default` (if `ALLOW`, all; if `DENY`, none). Example 6 (ListConstraint allowing all): `organizations/foo` has a `Policy` with values: {allowed_values: "E1"
+             * allowed_values: "E2"} `projects/bar` has a `Policy` with: {all: ALLOW} The accepted values at `organizations/foo` are `E1`, E2`. Any value is accepted at `projects/bar`. Example 7
+             * (ListConstraint allowing none): `organizations/foo` has a `Policy` with values: {allowed_values: "E1" allowed_values: "E2"} `projects/bar` has a `Policy` with: {all: DENY} The
+             * accepted values at `organizations/foo` are `E1`, E2`. No value is accepted at `projects/bar`. Example 10 (allowed and denied subtrees of Resource Manager hierarchy): Given the
+             * following resource hierarchy O1->{F1, F2}; F1->{P1}; F2->{P2, P3}, `organizations/foo` has a `Policy` with values: {allowed_values: "under:organizations/O1"} `projects/bar` has a
+             * `Policy` with: {allowed_values: "under:projects/P3"} {denied_values: "under:folders/F2"} The accepted values at `organizations/foo` are `organizations/O1`, `folders/F1`,
+             * `folders/F2`, `projects/P1`, `projects/P2`, `projects/P3`. The accepted values at `projects/bar` are `organizations/O1`, `folders/F1`, `projects/P1`.
+             */
+            inheritFromParent?: boolean;
+            /**
+             * Optional. The Google Cloud Console will try to default to a configuration that matches the value specified in this `Policy`. If `suggested_value` is not set, it will inherit the
+             * value specified higher in the hierarchy, unless `inherit_from_parent` is `false`.
+             */
+            suggestedValue?: string;
+        }
+        interface GoogleCloudOrgpolicyV1Policy {
+            /** For boolean `Constraints`, whether to enforce the `Constraint` or not. */
+            booleanPolicy?: GoogleCloudOrgpolicyV1BooleanPolicy;
+            /**
+             * The name of the `Constraint` the `Policy` is configuring, for example, `constraints/serviceuser.services`. A [list of available
+             * constraints](/resource-manager/docs/organization-policy/org-policy-constraints) is available. Immutable after creation.
+             */
+            constraint?: string;
+            /**
+             * An opaque tag indicating the current version of the `Policy`, used for concurrency control. When the `Policy` is returned from either a `GetPolicy` or a `ListOrgPolicy` request,
+             * this `etag` indicates the version of the current `Policy` to use when executing a read-modify-write loop. When the `Policy` is returned from a `GetEffectivePolicy` request, the
+             * `etag` will be unset. When the `Policy` is used in a `SetOrgPolicy` method, use the `etag` value that was returned from a `GetOrgPolicy` request as part of a read-modify-write loop
+             * for concurrency control. Not setting the `etag`in a `SetOrgPolicy` request will result in an unconditional write of the `Policy`.
+             */
+            etag?: string;
+            /** List of values either allowed or disallowed. */
+            listPolicy?: GoogleCloudOrgpolicyV1ListPolicy;
+            /** Restores the default behavior of the constraint; independent of `Constraint` type. */
+            restoreDefault?: any;
+            /**
+             * The time stamp the `Policy` was previously updated. This is set by the server, not specified by the caller, and represents the last time a call to `SetOrgPolicy` was made for that
+             * `Policy`. Any value set by the client will be ignored.
+             */
+            updateTime?: string;
+            /** Version of the `Policy`. Default version is 0; */
+            version?: number;
+        }
+        // tslint:disable-next-line:no-empty-interface
+        interface GoogleCloudOrgpolicyV1RestoreDefault {
+        }
+        interface GoogleIdentityAccesscontextmanagerV1AccessLevel {
+            /** A `BasicLevel` composed of `Conditions`. */
+            basic?: GoogleIdentityAccesscontextmanagerV1BasicLevel;
+            /** A `CustomLevel` written in the Common Expression Language. */
+            custom?: GoogleIdentityAccesscontextmanagerV1CustomLevel;
+            /** Description of the `AccessLevel` and its use. Does not affect behavior. */
+            description?: string;
+            /**
+             * Required. Resource name for the Access Level. The `short_name` component must begin with a letter and only include alphanumeric and '_'. Format:
+             * `accessPolicies/{access_policy}/accessLevels/{access_level}`. The maximum length of the `access_level` component is 50 characters.
+             */
+            name?: string;
+            /** Human readable title. Must be unique within the Policy. */
+            title?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1AccessPolicy {
+            /**
+             * Output only. An opaque identifier for the current version of the `AccessPolicy`. This will always be a strongly validated etag, meaning that two Access Polices will be identical if
+             * and only if their etags are identical. Clients should not expect this to be in any specific format.
+             */
+            etag?: string;
+            /** Output only. Resource name of the `AccessPolicy`. Format: `accessPolicies/{access_policy}` */
+            name?: string;
+            /** Required. The parent of this `AccessPolicy` in the Cloud Resource Hierarchy. Currently immutable once created. Format: `organizations/{organization_id}` */
+            parent?: string;
+            /**
+             * The scopes of a policy define which resources an ACM policy can restrict, and where ACM resources can be referenced. For example, a policy with scopes=["folders/123"] has the
+             * following behavior: - vpcsc perimeters can only restrict projects within folders/123 - access levels can only be referenced by resources within folders/123. If empty, there are no
+             * limitations on which resources can be restricted by an ACM policy, and there are no limitations on where ACM resources can be referenced. Only one policy can include a given scope
+             * (attempting to create a second policy which includes "folders/123" will result in an error). Currently, scopes cannot be modified after a policy is created. Currently, policies can
+             * only have a single scope. Format: list of `folders/{folder_number}` or `projects/{project_number}`
+             */
+            scopes?: string[];
+            /** Required. Human readable title. Does not affect behavior. */
+            title?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1ApiOperation {
+            /**
+             * API methods or permissions to allow. Method or permission must belong to the service specified by `service_name` field. A single MethodSelector entry with `*` specified for the
+             * `method` field will allow all methods AND permissions for the service specified in `service_name`.
+             */
+            methodSelectors?: GoogleIdentityAccesscontextmanagerV1MethodSelector[];
+            /**
+             * The name of the API whose methods or permissions the IngressPolicy or EgressPolicy want to allow. A single ApiOperation with `service_name` field set to `*` will allow all methods
+             * AND permissions for all services.
+             */
+            serviceName?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1BasicLevel {
+            /**
+             * How the `conditions` list should be combined to determine if a request is granted this `AccessLevel`. If AND is used, each `Condition` in `conditions` must be satisfied for the
+             * `AccessLevel` to be applied. If OR is used, at least one `Condition` in `conditions` must be satisfied for the `AccessLevel` to be applied. Default behavior is AND.
+             */
+            combiningFunction?: string;
+            /** Required. A list of requirements for the `AccessLevel` to be granted. */
+            conditions?: GoogleIdentityAccesscontextmanagerV1Condition[];
+        }
+        interface GoogleIdentityAccesscontextmanagerV1Condition {
+            /** Device specific restrictions, all restrictions must hold for the Condition to be true. If not specified, all devices are allowed. */
+            devicePolicy?: GoogleIdentityAccesscontextmanagerV1DevicePolicy;
+            /**
+             * CIDR block IP subnetwork specification. May be IPv4 or IPv6. Note that for a CIDR IP address block, the specified IP address portion must be properly truncated (i.e. all the host
+             * bits must be zero) or the input is considered malformed. For example, "192.0.2.0/24" is accepted but "192.0.2.1/24" is not. Similarly, for IPv6, "2001:db8::/32" is accepted whereas
+             * "2001:db8::1/32" is not. The originating IP of a request must be in one of the listed subnets in order for this Condition to be true. If empty, all IP addresses are allowed.
+             */
+            ipSubnetworks?: string[];
+            /**
+             * The request must be made by one of the provided user or service accounts. Groups are not supported. Syntax: `user:{emailid}` `serviceAccount:{emailid}` If not specified, a request
+             * may come from any user.
+             */
+            members?: string[];
+            /**
+             * Whether to negate the Condition. If true, the Condition becomes a NAND over its non-empty fields, each field must be false for the Condition overall to be satisfied. Defaults to
+             * false.
+             */
+            negate?: boolean;
+            /** The request must originate from one of the provided countries/regions. Must be valid ISO 3166-1 alpha-2 codes. */
+            regions?: string[];
+            /**
+             * A list of other access levels defined in the same `Policy`, referenced by resource name. Referencing an `AccessLevel` which does not exist is an error. All access levels listed must
+             * be granted for the Condition to be true. Example: "`accessPolicies/MY_POLICY/accessLevels/LEVEL_NAME"`
+             */
+            requiredAccessLevels?: string[];
+        }
+        interface GoogleIdentityAccesscontextmanagerV1CustomLevel {
+            /** Required. A Cloud CEL expression evaluating to a boolean. */
+            expr?: Expr;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1DevicePolicy {
+            /** Allowed device management levels, an empty list allows all management levels. */
+            allowedDeviceManagementLevels?: string[];
+            /** Allowed encryptions statuses, an empty list allows all statuses. */
+            allowedEncryptionStatuses?: string[];
+            /** Allowed OS versions, an empty list allows all types and all versions. */
+            osConstraints?: GoogleIdentityAccesscontextmanagerV1OsConstraint[];
+            /** Whether the device needs to be approved by the customer admin. */
+            requireAdminApproval?: boolean;
+            /** Whether the device needs to be corp owned. */
+            requireCorpOwned?: boolean;
+            /** Whether or not screenlock is required for the DevicePolicy to be true. Defaults to `false`. */
+            requireScreenlock?: boolean;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1EgressFrom {
+            /**
+             * A list of identities that are allowed access through this [EgressPolicy]. Should be in the format of email address. The email address should represent individual user or service
+             * account only.
+             */
+            identities?: string[];
+            /** Specifies the type of identities that are allowed access to outside the perimeter. If left unspecified, then members of `identities` field will be allowed access. */
+            identityType?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1EgressPolicy {
+            /** Defines conditions on the source of a request causing this EgressPolicy to apply. */
+            egressFrom?: GoogleIdentityAccesscontextmanagerV1EgressFrom;
+            /** Defines the conditions on the ApiOperation and destination resources that cause this EgressPolicy to apply. */
+            egressTo?: GoogleIdentityAccesscontextmanagerV1EgressTo;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1EgressTo {
+            /**
+             * A list of external resources that are allowed to be accessed. Only AWS and Azure resources are supported. For Amazon S3, the supported format is s3://BUCKET_NAME. For Azure Storage,
+             * the supported format is azure://myaccount.blob.core.windows.net/CONTAINER_NAME. A request matches if it contains an external resource in this list (Example: s3://bucket/path).
+             * Currently '*' is not allowed.
+             */
+            externalResources?: string[];
+            /** A list of ApiOperations allowed to be performed by the sources specified in the corresponding EgressFrom. A request matches if it uses an operation/service in this list. */
+            operations?: GoogleIdentityAccesscontextmanagerV1ApiOperation[];
+            /**
+             * A list of resources, currently only projects in the form `projects/`, that are allowed to be accessed by sources defined in the corresponding EgressFrom. A request matches if it
+             * contains a resource in this list. If `*` is specified for `resources`, then this EgressTo rule will authorize access to all resources outside the perimeter.
+             */
+            resources?: string[];
+        }
+        interface GoogleIdentityAccesscontextmanagerV1IngressFrom {
+            /**
+             * A list of identities that are allowed access through this ingress policy. Should be in the format of email address. The email address should represent individual user or service
+             * account only.
+             */
+            identities?: string[];
+            /** Specifies the type of identities that are allowed access from outside the perimeter. If left unspecified, then members of `identities` field will be allowed access. */
+            identityType?: string;
+            /** Sources that this IngressPolicy authorizes access from. */
+            sources?: GoogleIdentityAccesscontextmanagerV1IngressSource[];
+        }
+        interface GoogleIdentityAccesscontextmanagerV1IngressPolicy {
+            /** Defines the conditions on the source of a request causing this IngressPolicy to apply. */
+            ingressFrom?: GoogleIdentityAccesscontextmanagerV1IngressFrom;
+            /** Defines the conditions on the ApiOperation and request destination that cause this IngressPolicy to apply. */
+            ingressTo?: GoogleIdentityAccesscontextmanagerV1IngressTo;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1IngressSource {
+            /**
+             * An AccessLevel resource name that allow resources within the ServicePerimeters to be accessed from the internet. AccessLevels listed must be in the same policy as this
+             * ServicePerimeter. Referencing a nonexistent AccessLevel will cause an error. If no AccessLevel names are listed, resources within the perimeter can only be accessed via Google Cloud
+             * calls with request origins within the perimeter. Example: `accessPolicies/MY_POLICY/accessLevels/MY_LEVEL`. If a single `*` is specified for `access_level`, then all IngressSources
+             * will be allowed.
+             */
+            accessLevel?: string;
+            /**
+             * A Google Cloud resource that is allowed to ingress the perimeter. Requests from these resources will be allowed to access perimeter data. Currently only projects are allowed.
+             * Format: `projects/{project_number}` The project may be in any Google Cloud organization, not just the organization that the perimeter is defined in. `*` is not allowed, the case of
+             * allowing all Google Cloud resources only is not supported.
+             */
+            resource?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1IngressTo {
+            /** A list of ApiOperations allowed to be performed by the sources specified in corresponding IngressFrom in this ServicePerimeter. */
+            operations?: GoogleIdentityAccesscontextmanagerV1ApiOperation[];
+            /**
+             * A list of resources, currently only projects in the form `projects/`, protected by this ServicePerimeter that are allowed to be accessed by sources defined in the corresponding
+             * IngressFrom. If a single `*` is specified, then access to all resources inside the perimeter are allowed.
+             */
+            resources?: string[];
+        }
+        interface GoogleIdentityAccesscontextmanagerV1MethodSelector {
+            /**
+             * Value for `method` should be a valid method name for the corresponding `service_name` in ApiOperation. If `*` used as value for `method`, then ALL methods and permissions are
+             * allowed.
+             */
+            method?: string;
+            /** Value for `permission` should be a valid Cloud IAM permission for the corresponding `service_name` in ApiOperation. */
+            permission?: string;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1OsConstraint {
+            /** The minimum allowed OS version. If not set, any version of this OS satisfies the constraint. Format: `"major.minor.patch"`. Examples: `"10.5.301"`, `"9.2.1"`. */
+            minimumVersion?: string;
+            /** Required. The allowed OS type. */
+            osType?: string;
+            /**
+             * Only allows requests from devices with a verified Chrome OS. Verifications includes requirements that the device is enterprise-managed, conformant to domain policies, and the caller
+             * has permission to call the API targeted by the request.
+             */
+            requireVerifiedChromeOs?: boolean;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1ServicePerimeter {
+            /** Description of the `ServicePerimeter` and its use. Does not affect behavior. */
+            description?: string;
+            /**
+             * Required. Resource name for the ServicePerimeter. The `short_name` component must begin with a letter and only include alphanumeric and '_'. Format:
+             * `accessPolicies/{access_policy}/servicePerimeters/{service_perimeter}`
+             */
+            name?: string;
+            /**
+             * Perimeter type indicator. A single project is allowed to be a member of single regular perimeter, but multiple service perimeter bridges. A project cannot be a included in a
+             * perimeter bridge without being included in regular perimeter. For perimeter bridges, the restricted service list as well as access level lists must be empty.
+             */
+            perimeterType?: string;
+            /**
+             * Proposed (or dry run) ServicePerimeter configuration. This configuration allows to specify and test ServicePerimeter configuration without enforcing actual access restrictions. Only
+             * allowed to be set when the "use_explicit_dry_run_spec" flag is set.
+             */
+            spec?: GoogleIdentityAccesscontextmanagerV1ServicePerimeterConfig;
+            /** Current ServicePerimeter configuration. Specifies sets of resources, restricted services and access levels that determine perimeter content and boundaries. */
+            status?: GoogleIdentityAccesscontextmanagerV1ServicePerimeterConfig;
+            /** Human readable title. Must be unique within the Policy. */
+            title?: string;
+            /**
+             * Use explicit dry run spec flag. Ordinarily, a dry-run spec implicitly exists for all Service Perimeters, and that spec is identical to the status for those Service Perimeters. When
+             * this flag is set, it inhibits the generation of the implicit spec, thereby allowing the user to explicitly provide a configuration ("spec") to use in a dry-run version of the
+             * Service Perimeter. This allows the user to test changes to the enforced config ("status") without actually enforcing them. This testing is done through analyzing the differences
+             * between currently enforced and suggested restrictions. use_explicit_dry_run_spec must bet set to True if any of the fields in the spec are set to non-default values.
+             */
+            useExplicitDryRunSpec?: boolean;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1ServicePerimeterConfig {
+            /**
+             * A list of `AccessLevel` resource names that allow resources within the `ServicePerimeter` to be accessed from the internet. `AccessLevels` listed must be in the same policy as this
+             * `ServicePerimeter`. Referencing a nonexistent `AccessLevel` is a syntax error. If no `AccessLevel` names are listed, resources within the perimeter can only be accessed via Google
+             * Cloud calls with request origins within the perimeter. Example: `"accessPolicies/MY_POLICY/accessLevels/MY_LEVEL"`. For Service Perimeter Bridge, must be empty.
+             */
+            accessLevels?: string[];
+            /**
+             * List of EgressPolicies to apply to the perimeter. A perimeter may have multiple EgressPolicies, each of which is evaluated separately. Access is granted if any EgressPolicy grants
+             * it. Must be empty for a perimeter bridge.
+             */
+            egressPolicies?: GoogleIdentityAccesscontextmanagerV1EgressPolicy[];
+            /**
+             * List of IngressPolicies to apply to the perimeter. A perimeter may have multiple IngressPolicies, each of which is evaluated separately. Access is granted if any Ingress Policy
+             * grants it. Must be empty for a perimeter bridge.
+             */
+            ingressPolicies?: GoogleIdentityAccesscontextmanagerV1IngressPolicy[];
+            /** A list of Google Cloud resources that are inside of the service perimeter. Currently only projects are allowed. Format: `projects/{project_number}` */
+            resources?: string[];
+            /**
+             * Google Cloud services that are subject to the Service Perimeter restrictions. For example, if `storage.googleapis.com` is specified, access to the storage buckets inside the
+             * perimeter must meet the perimeter's access restrictions.
+             */
+            restrictedServices?: string[];
+            /** Configuration for APIs allowed within Perimeter. */
+            vpcAccessibleServices?: GoogleIdentityAccesscontextmanagerV1VpcAccessibleServices;
+        }
+        interface GoogleIdentityAccesscontextmanagerV1VpcAccessibleServices {
+            /**
+             * The list of APIs usable within the Service Perimeter. Must be empty unless 'enable_restriction' is True. You can specify a list of individual services, as well as include the
+             * 'RESTRICTED-SERVICES' value, which automatically includes all of the services protected by the perimeter.
+             */
+            allowedServices?: string[];
+            /** Whether to restrict API calls within the Service Perimeter to the list of APIs specified in 'allowed_services'. */
+            enableRestriction?: boolean;
+        }
+        interface Operation {
+            /** If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available. */
+            done?: boolean;
+            /** The error result of the operation in case of failure or cancellation. */
+            error?: Status;
+            /**
+             * Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such
+             * metadata. Any method that returns a long-running operation should document the metadata type, if any.
+             */
+            metadata?: { [P in string]: any };
+            /**
+             * The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending
+             * with `operations/{unique_id}`.
+             */
+            name?: string;
+            /**
+             * The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the
+             * original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the
+             * original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
+             */
+            response?: { [P in string]: any };
+        }
+        interface Policy {
+            /** Specifies cloud audit logging configuration for this policy. */
+            auditConfigs?: AuditConfig[];
+            /**
+             * Associates a list of `members`, or principals, with a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings`
+             * must contain at least one principal. The `bindings` in a `Policy` can refer to up to 1,500 principals; up to 250 of these principals can be Google groups. Each occurrence of a
+             * principal counts towards these limits. For example, if the `bindings` grant 50 different roles to `user:alice@example.com`, and not to any other principal, then you can add another
+             * 1,450 principals to the `bindings` in the `Policy`.
+             */
+            bindings?: Binding[];
+            /**
+             * `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make
+             * use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems
+             * are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM
+             * Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1`
+             * policy, and all of the conditions in the version `3` policy are lost.
+             */
+            etag?: string;
+            /**
+             * Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings
+             * must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a
+             * policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use
+             * IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1`
+             * policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave
+             * the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
+             */
+            version?: number;
+        }
+        interface Status {
+            /** The status code, which should be an enum value of google.rpc.Code. */
+            code?: number;
+            /** A list of messages that carry the error details. There is a common set of message types for APIs to use. */
+            details?: Array<{ [P in string]: any }>;
+            /**
+             * A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the
+             * client.
+             */
+            message?: string;
+        }
+        interface OperationsResource {
+            /** Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. */
+            get(request?: {
+                /** 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;
+                /** The name of the operation resource. */
+                name: 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;
+                /** Upload protocol for media (e.g. "raw", "multipart"). */
+                upload_protocol?: string;
+                /** Legacy upload protocol for media (e.g. "media", "multipart"). */
+                uploadType?: string;
+            }): Request<Operation>;
+        }
+        interface V1p7beta1Resource {
+            /**
+             * Exports assets with time and resource types to a given Cloud Storage location/BigQuery table. For Cloud Storage location destinations, the output format is newline-delimited JSON.
+             * Each line represents a google.cloud.asset.v1p7beta1.Asset in the JSON format; for BigQuery table destinations, the output table stores the fields in asset proto as columns. This API
+             * implements the google.longrunning.Operation API , which allows you to keep track of the export. We recommend intervals of at least 2 seconds with exponential retry to poll the
+             * export operation result. For regular-size resource parent, the export operation usually finishes within 5 minutes.
+             */
+            exportAssets(request: {
+                /** 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;
+                /**
+                 * Required. The relative name of the root asset. This can only be an organization number (such as "organizations/123"), a project ID (such as "projects/my-project-id"), or a
+                 * project number (such as "projects/12345"), or a folder number (such as "folders/123").
+                 */
+                parent: 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;
+                /** Upload protocol for media (e.g. "raw", "multipart"). */
+                upload_protocol?: string;
+                /** Legacy upload protocol for media (e.g. "media", "multipart"). */
+                uploadType?: string;
+                /** Request body */
+                resource: GoogleCloudAssetV1p7beta1ExportAssetsRequest;
+            }): Request<Operation>;
+            exportAssets(request: {
+                /** 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;
+                /**
+                 * Required. The relative name of the root asset. This can only be an organization number (such as "organizations/123"), a project ID (such as "projects/my-project-id"), or a
+                 * project number (such as "projects/12345"), or a folder number (such as "folders/123").
+                 */
+                parent: 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;
+                /** Upload protocol for media (e.g. "raw", "multipart"). */
+                upload_protocol?: string;
+                /** Legacy upload protocol for media (e.g. "media", "multipart"). */
+                uploadType?: string;
+            },
+            body: GoogleCloudAssetV1p7beta1ExportAssetsRequest): Request<Operation>;
+        }
+
+        const operations: OperationsResource;
+
+        const v1p7beta1: V1p7beta1Resource;
+    }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@maxim_mazurok/gapi.client.cloudasset-v1p7beta1",
+  "version": "0.0.20220805",
+  "description": "TypeScript typings for Cloud Asset API v1p7beta1",
+  "license": "MIT",
+  "author": {
+    "email": "maxim@mazurok.com",
+    "name": "Maxim Mazurok",
+    "url": "https://maxim.mazurok.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Maxim-Mazurok/google-api-typings-generator.git"
+  },
+  "types": "index.d.ts",
+  "dependencies": {
+    "@types/gapi.client": "*",
+    "@types/gapi.client.discovery": "*"
+  }
+}

package/readme.md

@@ -0,0 +1,78 @@
+# TypeScript typings for Cloud Asset API v1p7beta1
+
+The cloud asset API manages the history and inventory of cloud resources.
+For detailed description please check [documentation](https://cloud.google.com/asset-inventory/docs/quickstart).
+
+## Installing
+
+Install typings for Cloud Asset API:
+
+```
+npm install @types/gapi.client.cloudasset-v1p7beta1 --save-dev
+```
+
+## Usage
+
+You need to initialize Google API client in your code:
+
+```typescript
+gapi.load('client', () => {
+  // now we can use gapi.client
+  // ...
+});
+```
+
+Then load api client wrapper:
+
+```typescript
+gapi.client.load('https://cloudasset.googleapis.com/$discovery/rest?version=v1p7beta1', () => {
+  // now we can use:
+  // gapi.client.cloudasset
+});
+```
+
+```typescript
+// Deprecated, use discovery document URL, see https://github.com/google/google-api-javascript-client/blob/master/docs/reference.md#----gapiclientloadname----version----callback--
+gapi.client.load('cloudasset', 'v1p7beta1', () => {
+  // now we can use:
+  // gapi.client.cloudasset
+});
+```
+
+Don't forget to authenticate your client before sending any request to resources:
+
+```typescript
+// declare client_id registered in Google Developers Console
+var client_id = '',
+  scope = [
+      // See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account.
+      'https://www.googleapis.com/auth/cloud-platform',
+    ],
+    immediate = true;
+// ...
+
+gapi.auth.authorize(
+  { client_id: client_id, scope: scope, immediate: immediate },
+  authResult => {
+    if (authResult && !authResult.error) {
+        /* handle successful authorization */
+    } else {
+        /* handle authorization error */
+    }
+});
+```
+
+After that you can use Cloud Asset API resources: <!-- TODO: make this work for multiple namespaces -->
+
+```typescript
+
+/*
+Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
+*/
+await gapi.client.cloudasset.operations.get({ name: "name",  });
+
+/*
+Exports assets with time and resource types to a given Cloud Storage location/BigQuery table. For Cloud Storage location destinations, the output format is newline-delimited JSON. Each line represents a google.cloud.asset.v1p7beta1.Asset in the JSON format; for BigQuery table destinations, the output table stores the fields in asset proto as columns. This API implements the google.longrunning.Operation API , which allows you to keep track of the export. We recommend intervals of at least 2 seconds with exponential retry to poll the export operation result. For regular-size resource parent, the export operation usually finishes within 5 minutes.
+*/
+await gapi.client.cloudasset.exportAssets({ parent: "parent",  });
+```

package/tests.ts

@@ -0,0 +1,70 @@
+/* This is stub file for gapi.client.cloudasset-v1p7beta1 definition tests */
+// IMPORTANT
+// This file was generated by https://github.com/Maxim-Mazurok/google-api-typings-generator. Please do not edit it manually.
+// In case of any problems please post issue to https://github.com/Maxim-Mazurok/google-api-typings-generator
+
+// Revision: 20220805
+
+gapi.load('client', async () => {
+    /** now we can use gapi.client */
+
+    await gapi.client.load('https://cloudasset.googleapis.com/$discovery/rest?version=v1p7beta1');
+    /** now we can use gapi.client.cloudasset */
+
+    /** don't forget to authenticate your client before sending any request to resources: */
+    /** declare client_id registered in Google Developers Console */
+    const client_id = '<<PUT YOUR CLIENT ID HERE>>';
+    const scope = [
+        /** See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account. */
+        'https://www.googleapis.com/auth/cloud-platform',
+    ];
+    const immediate = false;
+    gapi.auth.authorize({ client_id, scope, immediate }, authResult => {
+        if (authResult && !authResult.error) {
+            /** handle successful authorization */
+            run();
+        } else {
+            /** handle authorization error */
+        }
+    });
+
+    async function run() {
+        /** Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. */
+        await gapi.client.cloudasset.operations.get({
+            name: "Test string",
+        });
+        /**
+         * Exports assets with time and resource types to a given Cloud Storage location/BigQuery table. For Cloud Storage location destinations, the output format is newline-delimited JSON. Each
+         * line represents a google.cloud.asset.v1p7beta1.Asset in the JSON format; for BigQuery table destinations, the output table stores the fields in asset proto as columns. This API
+         * implements the google.longrunning.Operation API , which allows you to keep track of the export. We recommend intervals of at least 2 seconds with exponential retry to poll the export
+         * operation result. For regular-size resource parent, the export operation usually finishes within 5 minutes.
+         */
+        await gapi.client.cloudasset.v1p7beta1.exportAssets({
+            parent: "Test string",
+        }, {
+            assetTypes: [
+                "Test string"
+            ],
+            contentType: "Test string",
+            outputConfig: {
+                bigqueryDestination: {
+                    dataset: "Test string",
+                    force: true,
+                    partitionSpec: {
+                        partitionKey: "Test string",
+                    },
+                    separateTablesPerAssetType: true,
+                    table: "Test string",
+                },
+                gcsDestination: {
+                    uri: "Test string",
+                    uriPrefix: "Test string",
+                },
+            },
+            readTime: "Test string",
+            relationshipTypes: [
+                "Test string"
+            ],
+        });
+    }
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": ["es6", "dom"],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "strictFunctionTypes": true
+    },
+    "files": ["index.d.ts", "tests.ts"]
+}

package/tslint.json

@@ -0,0 +1,6 @@
+{
+    "extends": "dtslint/dtslint.json",
+    "rules": {
+        "no-redundant-jsdoc": false
+    }
+}