googleapis
Version:
Google APIs Client Library for Node.js
1,095 lines • 539 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 saasservicemgmt_v1beta1 {
export interface Options extends GlobalOptions {
version: 'v1beta1';
}
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;
}
/**
* App Lifecycle Manager API
*
* Model, deploy, and operate your SaaS at scale.
*
* @example
* ```js
* const {google} = require('googleapis');
* const saasservicemgmt = google.saasservicemgmt('v1beta1');
* ```
*/
export class Saasservicemgmt {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Represents the aggregation of a set of population of like records by a certain group. For example, a collection of unit counts can be aggregated and grouped by their state.
*/
export interface Schema$Aggregate {
/**
* Required. Number of records in the group.
*/
count?: number | null;
/**
* Required. Group by which to aggregate.
*/
group?: string | null;
}
/**
* Allocation defines a set of weighted flag variants, specifying how traffic is split based on the randomization unit.
*/
export interface Schema$Allocation {
/**
* Optional. Description of the allocation. Max length: 500 bytes.
*/
description?: string | null;
/**
* Required. Allocation ID. Max length: 128 bytes.
*/
id?: string | null;
/**
* Required. Key of the context attribute that is used for traffic splitting.
*/
randomizedOn?: string | null;
/**
* Required. Slots defines the weighted distribution of variants.
*/
slots?: Schema$AllocationSlot[];
}
/**
* AllocationSlot specifies a variant and the proportion of traffic allocated to it.
*/
export interface Schema$AllocationSlot {
/**
* Required. Variant of the allocation slot.
*/
variant?: string | null;
/**
* Required. Weight defines the proportion of traffic to allocate to the variant, relative to other slots in the same allocation.
*/
weight?: number | null;
}
/**
* AppParams contains the parameters for creating an AppHub Application.
*/
export interface Schema$AppParams {
/**
* Grouping used to construct the name of the AppHub Application. Multiple UnitKinds can specify the same group to use the same Application across their respective units. Corresponds to the app_boundary_id in the ADC composite ApplicationTemplate. Defaults to UnitKind.name
*/
group?: string | null;
/**
* Corresponds to the scope in the ADC composite ApplicationTemplate. Defaults to TYPE_REGIONAL.
*/
scope?: Schema$Scope;
}
/**
* Blueprints are OCI Images that contain all of the artifacts needed to provision a unit. Metadata such as, type of the engine used to actuate the blueprint (e.g. terraform, helm etc) and version will come from the image manifest. If the hostname is omitted, it will be assumed to be the regional path to Artifact Registry (eg. us-east1-docker.pkg.dev).
*/
export interface Schema$Blueprint {
/**
* Output only. Type of the engine used to actuate the blueprint. e.g. terraform, helm etc.
*/
engine?: string | null;
/**
* Optional. Immutable. URI to a blueprint used by the Unit (required unless unitKind or release is set).
*/
package?: string | null;
/**
* Output only. Version metadata if present on the blueprint.
*/
version?: string | null;
}
/**
* ComponentRef represents a reference to a component resource.
*/
export interface Schema$ComponentRef {
/**
* Optional. Name of the component in composite.Components
*/
component?: string | null;
/**
* Reference to the Composite ApplicationTemplate.
*/
compositeRef?: Schema$CompositeRef;
/**
* Revision of the component. If the component does not have a revision, this field will be explicitly set to the revision of the composite ApplicationTemplate.
*/
revision?: string | null;
}
/**
* CompositeRef represents a reference to a composite resource.
*/
export interface Schema$CompositeRef {
/**
* Required. Reference to the ApplicationTemplate resource.
*/
applicationTemplate?: string | null;
/**
* Revision of the ApplicationTemplate to use. Changes to revision will trigger manual resynchronization. If empty, ApplicationTemplate will be ignored.
*/
revision?: string | null;
/**
* Output only. Reference to on-going AppTemplate import and replication operation (i.e. the operation_id for the long-running operation). This field is opaque for external usage.
*/
syncOperation?: string | null;
}
/**
* A representation of a decimal value, such as 2.5. Clients may convert values into language-native decimal formats, such as Java's [BigDecimal](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/math/BigDecimal.html) or Python's [decimal.Decimal](https://docs.python.org/3/library/decimal.html).
*/
export interface Schema$Decimal {
/**
* The decimal value, as a string. The string representation consists of an optional sign, `+` (`U+002B`) or `-` (`U+002D`), followed by a sequence of zero or more decimal digits ("the integer"), optionally followed by a fraction, optionally followed by an exponent. An empty string **should** be interpreted as `0`. The fraction consists of a decimal point followed by zero or more decimal digits. The string must contain at least one digit in either the integer or the fraction. The number formed by the sign, the integer and the fraction is referred to as the significand. The exponent consists of the character `e` (`U+0065`) or `E` (`U+0045`) followed by one or more decimal digits. Services **should** normalize decimal values before storing them by: - Removing an explicitly-provided `+` sign (`+2.5` -\> `2.5`). - Replacing a zero-length integer value with `0` (`.5` -\> `0.5`). - Coercing the exponent character to upper-case, with explicit sign (`2.5e8` -\> `2.5E+8`). - Removing an explicitly-provided zero exponent (`2.5E0` -\> `2.5`). Services **may** perform additional normalization based on its own needs and the internal decimal implementation selected, such as shifting the decimal point and exponent value together (example: `2.5E-1` <-\> `0.25`). Additionally, services **may** preserve trailing zeroes in the fraction to indicate increased precision, but are not required to do so. Note that only the `.` character is supported to divide the integer and the fraction; `,` **should not** be supported regardless of locale. Additionally, thousand separators **should not** be supported. If a service does support them, values **must** be normalized. The ENBF grammar is: DecimalString = '' | [Sign] Significand [Exponent]; Sign = '+' | '-'; Significand = Digits '.' | [Digits] '.' Digits; Exponent = ('e' | 'E') [Sign] Digits; Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' \}; Services **should** clearly document the range of supported values, the maximum supported precision (total number of digits), and, if applicable, the scale (number of digits after the decimal point), as well as how it behaves when receiving out-of-bounds values. Services **may** choose to accept values passed as input even when the value has a higher precision or scale than the service supports, and **should** round the value to fit the supported scale. Alternatively, the service **may** error with `400 Bad Request` (`INVALID_ARGUMENT` in gRPC) if precision would be lost. Services **should** error with `400 Bad Request` (`INVALID_ARGUMENT` in gRPC) if the service receives a value outside of the supported range.
*/
value?: string | null;
}
/**
* Dependency represent a single dependency with another unit kind by alias.
*/
export interface Schema$Dependency {
/**
* Required. An alias for the dependency. Used for input variable mapping.
*/
alias?: string | null;
/**
* Required. Immutable. The unit kind of the dependency.
*/
unitKind?: string | null;
}
/**
* Deprovision is the unit operation that deprovision the underlying resources represented by a Unit. Can only execute if the Unit is currently provisioned.
*/
export interface Schema$Deprovision {
}
/**
* 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 {
}
/**
* The configuration for error budget. If the number of failed units exceeds max(allowed_count, allowed_ratio * total_units), the rollout will be paused.
*/
export interface Schema$ErrorBudget {
/**
* Optional. The maximum number of failed units allowed in a location without pausing the rollout.
*/
allowedCount?: number | null;
/**
* Optional. The maximum percentage of units allowed to fail (0, 100] within a location without pausing the rollout.
*/
allowedPercentage?: number | null;
}
/**
* EvaluationRule defines a single rule for evaluating a feature flag. A rule consists of a condition that, if met, assigns a specific variant or allocation to the user.
*/
export interface Schema$EvaluationRule {
/**
* Optional. The ID of an allocation to target.
*/
allocationId?: string | null;
/**
* Required. A Common Expression Language (CEL) expression that evaluates to a boolean. The expression is evaluated against the provided context. If it returns true, the rule's target is applied.
*/
condition?: string | null;
/**
* Required. Evaluation rule ID. Max length: 128 bytes.
*/
id?: string | null;
/**
* Optional. Deprecated: Use `rule_target` instead. The target variant or allocation to apply if the condition is met. This should match the name of a defined variant or allocation's ID.
*/
target?: string | null;
/**
* Optional. The name of a variant to target.
*/
variantId?: string | null;
}
/**
* EvaluationSpec holds rules for evaluating the value of a flag.
*/
export interface Schema$EvaluationSpec {
/**
* Optional. A list of allocations.
*/
allocations?: Schema$Allocation[];
/**
* Optional. Names of the context attributes that are used in the evaluation rules and allocations.
*/
attributes?: string[] | null;
/**
* Optional. Deprecated: Use `base_target` instead. Default variant or allocation of the flag.
*/
defaultTarget?: string | null;
/**
* Optional. Evaluation rules define the logic for evaluating the flag against a given context. The rules are evaluated sequentially in their specified order.
*/
rules?: Schema$EvaluationRule[];
/**
* Optional. A list of variants.
*/
variants?: Schema$Variant[];
}
/**
* Represents a single Flag.
*/
export interface Schema$Flag {
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Optional. Description of the flag. Max length: 500 bytes.
*/
description?: string | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Optional. Specification of how the flag value should be evaluated. If a bool flag is created without an evaluation_spec specified, two default variants, "Enabled" (with bool_value = true) and "Disabled" (with bool_value = false), are created by default, and "Disabled" is set as the default_target.
*/
evaluationSpec?: Schema$EvaluationSpec;
/**
* Optional. Flag set this flag belongs to.
*/
flagSet?: string | null;
/**
* Optional. Immutable. Flag value type.
*/
flagValueType?: string | null;
/**
* Required. Immutable. Flag key used in runtime evaluation APIs (OpenFeature). Max length: 256 bytes.
*/
key?: string | null;
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/flags/{flag_id\}"
*/
name?: string | null;
/**
* Optional. Current state of the flag.
*/
state?: string | null;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Required. Immutable. UnitKind that can consume this flag.
*/
unitKind?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
*/
updateTime?: string | null;
/**
* Optional. Immutable. Deprecated: Use `flag_value_type` instead. Flag value type.
*/
valueType?: string | null;
/**
* Optional. A list of variants.
*/
variants?: Schema$FlagVariant[];
}
/**
* FlagAttribute defines a custom property in the evaluation context.
*/
export interface Schema$FlagAttribute {
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Optional. Immutable. Type of the attribute.
*/
attributeValueType?: string | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Required. Immutable. The identifier for the attribute, used as the key in the evaluation context. The attribute key is referenced in the evaluation rules and used in the OpenFeature evaluation API to specify the attribute context.
*/
key?: string | null;
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/flagAttributes/{flag_attribute_id\}"
*/
name?: string | null;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
*/
updateTime?: string | null;
/**
* Optional. Immutable. Deprecated: Use `attribute_value_type` instead. Type of the attribute.
*/
valueType?: string | null;
}
/**
* A collection of FlagRevisions.
*/
export interface Schema$FlagRelease {
/**
* Optional. Immutable. DEPRECATED: Use all_flags_release instead. Rollout all flags in the provided UnitKind. Only one of flag_revisions, all_flags, or flag_sets can be set.
*/
allFlags?: boolean | null;
/**
* Optional. Immutable. Specifies the release includes all flags.
*/
allFlagsRelease?: boolean | null;
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Output only. An OUTPUT_ONLY field that contains FlagRevisions to be rolled out. This is the ultimate source of truth of what a Rollout or a UnitOperation carries.
*/
effectiveFlagRevisions?: string[] | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Optional. Immutable. DEPRECATED: Use flag_revisions_release instead. FlagRevisions to be rolled out. Only one of flag_revisions, all_flags, or flag_sets can be set. It used to be the ultimate source to truth and has been moved to effective_flag_revisions.
*/
flagRevisions?: string[] | null;
/**
* Optional. Immutable. Specifies the release consisting of a list of flag revisions.
*/
flagRevisionsRelease?: Schema$FlagRevisionList;
/**
* Optional. Immutable. DEPRECATED: Use flag_sets_release instead. Flag sets to be rolled out. Only one of flag_revisions, all_flags, or flag_sets can be set.
*/
flagSets?: string[] | null;
/**
* Optional. Immutable. Specifies the release consisting of a list of flag sets.
*/
flagSetsRelease?: Schema$FlagSetList;
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/flagReleases/{flag_release_id\}"
*/
name?: string | null;
/**
* Optional. Immutable. Deprecated: Use the 'state' field in the 'Flag' resource to manage the cleanup of flag lifecycles including removal from UnitKind and Units. Flags to be removed from given UnitKind and all related Units. If Flag is provided here, its FlagRevisions will be removed from UnitKind and Units.
*/
obsoleteFlags?: string[] | null;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Required. Immutable. The UnitKind this FlagRelease applies to.
*/
unitKind?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
*/
updateTime?: string | null;
}
/**
* A snapshot of the EvaluationSpec for the Flag.
*/
export interface Schema$FlagRevision {
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Output only. Immutable. Snapshot of the EvaluationSpec for the flag. DEPRECATED: Use snapshot instead.
*/
evaluationSpec?: Schema$EvaluationSpec;
/**
* Required. Immutable. Name of the Flag this is a revision of.
*/
flag?: string | null;
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/flagRevisions/{flag_revision_id\}"
*/
name?: string | null;
/**
* Output only. Immutable. Snapshot of the Flag.
*/
snapshot?: Schema$Flag;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
*/
updateTime?: string | null;
}
/**
* Wrapper for a list of flag revisions.
*/
export interface Schema$FlagRevisionList {
/**
* Required. FlagRevisions to be rolled out.
*/
revisions?: string[] | null;
}
/**
* Wrapper for a list of flag sets.
*/
export interface Schema$FlagSetList {
/**
* Required. Flag sets to be rolled out.
*/
sets?: string[] | null;
}
/**
* FlagUpdate is a UnitOperation that pushes new flag values to Units.
*/
export interface Schema$FlagUpdate {
/**
* Required. Flag release being applied by UnitOperation.
*/
flagRelease?: string | null;
}
/**
* Variant is an identifier for a value (name assigned to a value).
*/
export interface Schema$FlagVariant {
/**
* Optional. Boolean variant value.
*/
booleanValue?: boolean | null;
/**
* Optional. A human-readable description of what this variant does or represents.
*/
description?: string | null;
/**
* Optional. Double variant value.
*/
doubleValue?: number | null;
/**
* Required. Variant ID. Max length: 128 bytes.
*/
id?: string | null;
/**
* Optional. Integer variant value.
*/
integerValue?: string | null;
/**
* Optional. String variant value.
*/
stringValue?: string | null;
/**
* Optional. trackingId is unique depending on name and value of the variant within the scope of the service. It is typically generated by the server and must not be changed. trackingId is used to uniquely identify and track variants.
*/
trackingId?: string | null;
}
/**
* Output variables whose values will be passed on to dependencies
*/
export interface Schema$FromMapping {
/**
* Required. Alias of the dependency that the outputVariable will pass its value to
*/
dependency?: string | null;
/**
* Required. Name of the outputVariable on the dependency
*/
outputVariable?: string | null;
}
/**
* A resource that represents a Google Cloud location.
*/
export interface Schema$GoogleCloudLocationLocation {
/**
* The friendly name for this location, typically a nearby city name. For example, "Tokyo".
*/
displayName?: string | null;
/**
* Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"\}
*/
labels?: {
[key: string]: string;
} | null;
/**
* The canonical id for this location. For example: `"us-east1"`.
*/
locationId?: string | null;
/**
* Service-specific metadata. For example the available capacity at the given location.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
*/
name?: string | null;
}
/**
* The response structure for the ListFlagAttributes method.
*/
export interface Schema$ListFlagAttributesResponse {
/**
* The resulting flag attributes.
*/
flagAttributes?: Schema$FlagAttribute[];
/**
* If present, the next page token can be provided to a subsequent ListFlagAttributes call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListFlagReleases method.
*/
export interface Schema$ListFlagReleasesResponse {
/**
* The resulting flag releases.
*/
flagReleases?: Schema$FlagRelease[];
/**
* If present, the next page token can be provided to a subsequent ListFlagReleases call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListFlagRevisions method.
*/
export interface Schema$ListFlagRevisionsResponse {
/**
* The resulting flag revisions.
*/
flagRevisions?: Schema$FlagRevision[];
/**
* If present, the next page token can be provided to a subsequent ListFlagRevisions call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListFlags method.
*/
export interface Schema$ListFlagsResponse {
/**
* The resulting flags.
*/
flags?: Schema$Flag[];
/**
* If present, the next page token can be provided to a subsequent ListFlags call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response message for Locations.ListLocations.
*/
export interface Schema$ListLocationsResponse {
/**
* A list of locations that matches the specified filter in the request.
*/
locations?: Schema$GoogleCloudLocationLocation[];
/**
* The standard List next-page token.
*/
nextPageToken?: string | null;
}
/**
* The response structure for the ListReleases method.
*/
export interface Schema$ListReleasesResponse {
/**
* If present, the next page token can be provided to a subsequent ListReleases call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting releases.
*/
releases?: Schema$Release[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListRolloutKinds method.
*/
export interface Schema$ListRolloutKindsResponse {
/**
* If present, the next page token can be provided to a subsequent ListRolloutKinds call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting rollout kinds.
*/
rolloutKinds?: Schema$RolloutKind[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListRollouts method.
*/
export interface Schema$ListRolloutsResponse {
/**
* If present, the next page token can be provided to a subsequent ListRollouts call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting rollouts.
*/
rollouts?: Schema$Rollout[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListSaasReleases method.
*/
export interface Schema$ListSaasReleasesResponse {
/**
* If present, the next page token can be provided to a subsequent ListSaasReleases call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting saas releases.
*/
saasReleases?: Schema$SaasRelease[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListSaas method.
*/
export interface Schema$ListSaasResponse {
/**
* If present, the next page token can be provided to a subsequent ListSaas call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting saas.
*/
saas?: Schema$Saas[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListTenants method.
*/
export interface Schema$ListTenantsResponse {
/**
* If present, the next page token can be provided to a subsequent ListTenants call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting tenants.
*/
tenants?: Schema$Tenant[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListUnitGroupOperations method.
*/
export interface Schema$ListUnitGroupOperationsResponse {
/**
* If present, the next page token can be provided to a subsequent ListUnitGroupOperations call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting unit group operations.
*/
unitGroupOperations?: Schema$UnitGroupOperation[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListUnitGroups method.
*/
export interface Schema$ListUnitGroupsResponse {
/**
* If present, the next page token can be provided to a subsequent ListUnitGroups call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting unit groups.
*/
unitGroups?: Schema$UnitGroup[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListUnitKinds method.
*/
export interface Schema$ListUnitKindsResponse {
/**
* If present, the next page token can be provided to a subsequent ListUnitKinds call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting unit kinds.
*/
unitKinds?: Schema$UnitKind[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListUnitOperations method.
*/
export interface Schema$ListUnitOperationsResponse {
/**
* If present, the next page token can be provided to a subsequent ListUnitOperations call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting unit operations.
*/
unitOperations?: Schema$UnitOperation[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response structure for the ListUnits method.
*/
export interface Schema$ListUnitsResponse {
/**
* If present, the next page token can be provided to a subsequent ListUnits call to list the next page. If empty, there are no more pages.
*/
nextPageToken?: string | null;
/**
* The resulting units.
*/
units?: Schema$Unit[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* Location information that the service is available in.
*/
export interface Schema$Location {
/**
* Optional. Name of location.
*/
name?: string | null;
}
/**
* Captures requested directives for performing future maintenance on the unit. This includes a request for the unit to skip maintenance for a period of time and remain pinned to its current release as well as controls for postponing maintenance scheduled in future.
*/
export interface Schema$MaintenanceSettings {
/**
* Optional. If present, it fixes the release on the unit until the given time; i.e. changes to the release field will be rejected. Rollouts should and will also respect this by not requesting an upgrade in the first place.
*/
pinnedUntilTime?: string | null;
}
/**
* Provision is the unit operation that provision the underlying resources represented by a Unit. Can only execute if the Unit is not currently provisioned.
*/
export interface Schema$Provision {
/**
* Optional. Set of input variables. Maximum 100. (optional)
*/
inputVariables?: Schema$UnitVariable[];
/**
* Optional. Reference to the Release object to use for the Unit. (optional).
*/
release?: string | null;
}
/**
* A new version to be propagated and deployed to units. This includes pointers to packaged blueprints for actuation (e.g Helm or Terraform configuration packages) via artifact registry.
*/
export interface Schema$Release {
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. Reference to component and revision in a composite ApplicationTemplate.
*/
applicationTemplateComponent?: Schema$ComponentRef;
/**
* Optional. Blueprints are OCI Images that contain all of the artifacts needed to provision a unit.
*/
blueprint?: Schema$Blueprint;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Optional. Mapping of input variables to default values. Maximum 100
*/
inputVariableDefaults?: Schema$UnitVariable[];
/**
* Optional. Output only. List of input variables declared on the blueprint and can be present with their values on the unit spec
*/
inputVariables?: Schema$UnitVariable[];
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/releases/{release\}"
*/
name?: string | null;
/**
* Optional. Output only. List of output variables declared on the blueprint and can be present with their values on the unit status
*/
outputVariables?: Schema$UnitVariable[];
/**
* Optional. Set of requirements to be fulfilled on the Unit when using this Release.
*/
releaseRequirements?: Schema$ReleaseRequirements;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Required. Immutable. Reference to the UnitKind this Release corresponds to (required and immutable once created).
*/
unitKind?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should refresh this value.
*/
updateTime?: string | null;
}
/**
* Set of requirements to be fulfilled on the Unit when using this Release.
*/
export interface Schema$ReleaseRequirements {
/**
* Optional. A list of releases from which a unit can be upgraded to this one (optional). If left empty no constraints will be applied. When provided, unit upgrade requests to this release will check and enforce this constraint.
*/
upgradeableFromReleases?: string[] | null;
}
/**
* Represents a single rollout execution and its results
*/
export interface Schema$Rollout {
/**
* Optional. Annotations is an unstructured key-value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: https://kubernetes.io/docs/user-guide/annotations
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Optional. Requested change to the execution of this rollout. Default RolloutControl.action is ROLLOUT_ACTION_RUN meaning the rollout will be executed to completion while progressing through all natural Rollout States (such as RUNNING -\> SUCCEEDED or RUNNING -\> FAILED). Requests can only be made when the Rollout is in a non-terminal state.
*/
control?: Schema$RolloutControl;
/**
* Output only. The timestamp when the resource was created.
*/
createTime?: string | null;
/**
* Output only. The timestamp when the resource was marked for deletion (deletion is an asynchronous operation).
*/
deleteTime?: string | null;
/**
* Optional. Output only. Output only snapshot of the effective unit filter at Rollout start time. Contains a CEL(https://github.com/google/cel-spec) expression consisting of a conjunction of Rollout.unit_filter and RolloutKind.unit_filter. This field captures the filter applied by the Rollout to determine the Unit population. If the associated RolloutKind's unit_filter is modified after the rollout is started, it will not be updated here.
*/
effectiveUnitFilter?: string | null;
/**
* Optional. Output only. The time when the rollout finished execution (regardless of success, failure, or cancellation). Will be empty if the rollout hasn't finished yet. Once set, the rollout is in terminal state and all the results are final.
*/
endTime?: string | null;
/**
* Output only. An opaque value that uniquely identifies a version or generation of a resource. It can be used to confirm that the client and server agree on the ordering of a resource being written.
*/
etag?: string | null;
/**
* Optional. Immutable. Name of the FlagRelease to be rolled out to the target Units. Release and FlagRelease are mutually exclusive. Note: `release` comment needs to be adjusted to mention that "Release and FlagRelease are mutually exclusive" when visibility restriction will be lifted.
*/
flagRelease?: string | null;
/**
* Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/rollout/{rollout_id\}"
*/
name?: string | null;
/**
* Optional. Output only. The direct parent rollout that this rollout is stemming from. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/rollouts/{rollout_id\}"
*/
parentRollout?: string | null;
/**
* Optional. Immutable. Name of the Release that gets rolled out to target Units. Required if no other type of release is specified.
*/
release?: string | null;
/**
* Required. Immutable. Name of the RolloutKind this rollout is stemming from and adhering to.
*/
rolloutKind?: string | null;
/**
* Optional. The strategy used for executing this Rollout. This strategy will override whatever strategy is specified in the RolloutKind. If not specified on creation, the strategy from RolloutKind will be used. There are two supported values strategies which are used to control - "Google.Cloud.Simple.AllAtOnce" - "Google.Cloud.Simple.OneLocationAtATime" A rollout with one of these simple strategies will rollout across all locations defined in the targeted UnitKind's Saas Locations.
*/
rolloutOrchestrationStrategy?: string | null;
/**
* Optional. Output only. The root rollout that this rollout is stemming from. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project\}/locations/{location\}/rollouts/{rollout_id\}"
*/
rootRollout?: string | null;
/**
* Optional. Output only. The time when the rollout started executing. Will be empty if the rollout hasn't started yet.
*/
startTime?: string | null;
/**
* Output only. Current state of the rollout.
*/
state?: string | null;
/**
* Output only. Human readable message indicating details about the last state transition.
*/
stateMessage?: string | null;
/**
* Optional. Output only. The time when the rollout transitioned into its current state.
*/
stateTransitionTime?: string | null;
/**
* Optional. Output only. Details about the progress of the rollout.
*/
stats?: Schema$RolloutStats;
/**
* Output only. The unique identifier of the resource. UID is unique in the time and space for this resource within the scope of the service. It is typically generated by the server on successful creation of a resource and must not be changed. UID is used to uniquely identify resources with resource name reuses. This should be a UUID4.
*/
uid?: string | null;
/**
* Optional. CEL(https://github.com/google/cel-spec) formatted filter string against Unit. The filter will be applied to determine the eligible unit population. This filter can only reduce, but not expand the scope of the rollout. If not provided, the unit_filter from the RolloutKind will be used.
*/
unitFilter?: string | null;
/**
* Output only. The timestamp when the resource was last updated. Any change to the resource made by users must refresh this value. Changes to a resource made by the service should ref