@distilled.cloud/gcp 0.4.0 → 0.5.0

package/lib/services/saasservicemgmt-v1.d.ts

@@ -0,0 +1,1269 @@
+import * as Schema from "effect/Schema";
+import * as API from "../client/api.ts";
+import type { Credentials } from "../credentials";
+import type { DefaultErrors } from "../errors";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+export interface GoogleCloudLocationLocation {
+    /** The friendly name for this location, typically a nearby city name. For example, "Tokyo". */
+    displayName?: string;
+    /** Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"` */
+    name?: string;
+    /** The canonical id for this location. For example: `"us-east1"`. */
+    locationId?: string;
+    /** Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"} */
+    labels?: Record<string, string>;
+    /** Service-specific metadata. For example the available capacity at the given location. */
+    metadata?: Record<string, unknown>;
+}
+export declare const GoogleCloudLocationLocation: Schema.Schema<GoogleCloudLocationLocation>;
+export interface UnitVariable {
+    /** Optional. Immutable. Name of a supported variable type. Supported types are string, int, bool. */
+    type?: "TYPE_UNSPECIFIED" | "STRING" | "INT" | "BOOL" | (string & {});
+    /** Required. Immutable. Name of the variable from actuation configs. */
+    variable?: string;
+    /** Optional. String encoded value for the variable. */
+    value?: string;
+}
+export declare const UnitVariable: Schema.Schema<UnitVariable>;
+export interface Upgrade {
+    /** Optional. Reference to the Release object to use for the Unit. (optional). */
+    release?: string;
+    /** Optional. Set of input variables. Maximum 100. (optional) */
+    inputVariables?: Array<UnitVariable>;
+}
+export declare const Upgrade: Schema.Schema<Upgrade>;
+export interface Provision {
+    /** Optional. Reference to the Release object to use for the Unit. (optional). */
+    release?: string;
+    /** Optional. Set of input variables. Maximum 100. (optional) */
+    inputVariables?: Array<UnitVariable>;
+}
+export declare const Provision: Schema.Schema<Provision>;
+export interface Deprovision {
+}
+export declare const Deprovision: Schema.Schema<Deprovision>;
+export interface UnitOperationCondition {
+    /** Required. Human readable message indicating details about the last transition. */
+    message?: string;
+    /** Required. Last time the condition transited from one status to another. */
+    lastTransitionTime?: string;
+    /** Required. Status of the condition. */
+    status?: "STATUS_UNSPECIFIED" | "STATUS_UNKNOWN" | "STATUS_TRUE" | "STATUS_FALSE" | (string & {});
+    /** Required. Brief reason for the condition's last transition. */
+    reason?: string;
+    /** Required. Type of the condition. */
+    type?: "TYPE_UNSPECIFIED" | "TYPE_SCHEDULED" | "TYPE_RUNNING" | "TYPE_SUCCEEDED" | "TYPE_CANCELLED" | "TYPE_APP_CREATED" | "TYPE_APP_COMPONENTS_REGISTERED" | (string & {});
+}
+export declare const UnitOperationCondition: Schema.Schema<UnitOperationCondition>;
+export interface Schedule {
+    /** Optional. Start of operation. If not set, will be set to the start of the next window. (optional) */
+    startTime?: string;
+}
+export declare const Schedule: Schema.Schema<Schedule>;
+export interface UnitOperation {
+    /** 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?: Record<string, string>;
+    upgrade?: Upgrade;
+    /** Optional. Output only. UnitOperationErrorCategory describe the error category. */
+    errorCategory?: "UNIT_OPERATION_ERROR_CATEGORY_UNSPECIFIED" | "NOT_APPLICABLE" | "FATAL" | "RETRIABLE" | "IGNORABLE" | "STANDARD" | (string & {});
+    /** 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;
+    /** Optional. Output only. The engine state for on-going deployment engine operation(s). This field is opaque for external usage. */
+    engineState?: string;
+    /** 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;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/unitOperations/{unitOperation}" */
+    name?: string;
+    /** Required. Immutable. The Unit a given UnitOperation will act upon. */
+    unit?: string;
+    provision?: Provision;
+    /** 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;
+    /** Optional. When true, attempt to cancel the operation. Cancellation may fail if the operation is already executing. (Optional) */
+    cancel?: boolean;
+    deprovision?: Deprovision;
+    /** Optional. Output only. UnitOperationState describes the current state of the unit operation. */
+    state?: "UNIT_OPERATION_STATE_UNKNOWN" | "UNIT_OPERATION_STATE_PENDING" | "UNIT_OPERATION_STATE_SCHEDULED" | "UNIT_OPERATION_STATE_RUNNING" | "UNIT_OPERATION_STATE_SUCCEEDED" | "UNIT_OPERATION_STATE_FAILED" | "UNIT_OPERATION_STATE_CANCELLED" | (string & {});
+    /** Optional. Reference to parent resource: UnitOperation. If an operation needs to create other operations as part of its workflow, each of the child operations should have this field set to the parent. This can be used for tracing. (Optional) */
+    parentUnitOperation?: string;
+    /** Optional. Output only. A set of conditions which indicate the various conditions this resource can have. */
+    conditions?: Array<UnitOperationCondition>;
+    /** Output only. The timestamp when the resource was marked for deletion (deletion is an asynchronous operation). */
+    deleteTime?: string;
+    /** Optional. When to schedule this operation. */
+    schedule?: Schedule;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** Optional. Specifies which rollout created this Unit Operation. This cannot be modified and is used for filtering purposes only. If a dependent unit and unit operation are created as part of another unit operation, they will use the same rolloutId. */
+    rollout?: string;
+}
+export declare const UnitOperation: Schema.Schema<UnitOperation>;
+export interface UnitCondition {
+    /** Required. Last time the condition transited from one status to another. */
+    lastTransitionTime?: string;
+    /** Required. Human readable message indicating details about the last transition. */
+    message?: string;
+    /** Required. Status of the condition. */
+    status?: "STATUS_UNSPECIFIED" | "STATUS_UNKNOWN" | "STATUS_TRUE" | "STATUS_FALSE" | (string & {});
+    /** Required. Brief reason for the condition's last transition. */
+    reason?: string;
+    /** Required. Type of the condition. */
+    type?: "TYPE_UNSPECIFIED" | "TYPE_READY" | "TYPE_UPDATING" | "TYPE_PROVISIONED" | "TYPE_OPERATION_ERROR" | (string & {});
+}
+export declare const UnitCondition: Schema.Schema<UnitCondition>;
+export 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<Record<string, unknown>>;
+    /** 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;
+}
+export declare const Status: Schema.Schema<Status>;
+export interface Location {
+    /** Optional. Name of location. */
+    name?: string;
+}
+export declare const Location: Schema.Schema<Location>;
+export interface Saas {
+    /** Optional. List of locations that the service is available in. Rollout refers to the list to generate a rollout plan. */
+    locations?: Array<Location>;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** 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;
+    /** 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;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** 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;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/saas/{saas}" */
+    name?: string;
+    /** 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?: Record<string, string>;
+}
+export declare const Saas: Schema.Schema<Saas>;
+export interface 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?: Array<string>;
+}
+export declare const ReleaseRequirements: Schema.Schema<ReleaseRequirements>;
+export interface ErrorBudget {
+    /** Optional. The maximum number of failed units allowed in a location without pausing the rollout. */
+    allowedCount?: number;
+    /** Optional. The maximum percentage of units allowed to fail (0, 100] within a location without pausing the rollout. */
+    allowedPercentage?: number;
+}
+export declare const ErrorBudget: Schema.Schema<ErrorBudget>;
+export interface RolloutKind {
+    /** Optional. Value among strict (enforcing maintenance policy and only looking at Units with maintenance policy), ignore (ignoring maintenance policy) and skip (skipping Units with maintenance policy) */
+    maintenancePolicyEnforcement?: "MAINTENANCE_POLICY_ENFORCEMENT_UNSPECIFIED" | "MAINTENANCE_POLICY_ENFORCEMENT_STRICT" | "MAINTENANCE_POLICY_ENFORCEMENT_IGNORED" | "MAINTENANCE_POLICY_ENFORCEMENT_SKIPPED" | (string & {});
+    /** 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;
+    /** 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;
+    /** 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;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/rolloutKinds/{rollout_kind_id}" */
+    name?: string;
+    /** 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. */
+    unitFilter?: string;
+    /** Optional. The strategy used for executing a Rollout. This is a required field. 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 associated UnitKind's Saas Locations. */
+    rolloutOrchestrationStrategy?: string;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Required. Immutable. UnitKind that this rollout kind corresponds to. Rollouts stemming from this rollout kind will target the units of this unit kind. In other words, this defines the population of target units to be upgraded by rollouts. */
+    unitKind?: string;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** Optional. The configuration for error budget. If the number of failed units exceeds max(allowed_count, allowed_ratio * total_units), the rollout will be paused. If not set, all units will be attempted to be updated regardless of the number of failures encountered. */
+    errorBudget?: ErrorBudget;
+    /** 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?: Record<string, string>;
+    /** Optional. The config for updating the unit kind. By default, the unit kind will be updated on the rollout start. */
+    updateUnitKindStrategy?: "UPDATE_UNIT_KIND_STRATEGY_UNSPECIFIED" | "UPDATE_UNIT_KIND_STRATEGY_ON_START" | "UPDATE_UNIT_KIND_STRATEGY_NEVER" | (string & {});
+}
+export declare const RolloutKind: Schema.Schema<RolloutKind>;
+export interface Blueprint {
+    /** Optional. Immutable. URI to a blueprint used by the Unit (required unless unitKind or release is set). */
+    package?: string;
+    /** Output only. Version metadata if present on the blueprint. */
+    version?: string;
+    /** Output only. Type of the engine used to actuate the blueprint. e.g. terraform, helm etc. */
+    engine?: string;
+}
+export declare const Blueprint: Schema.Schema<Blueprint>;
+export interface Release {
+    /** Optional. Set of requirements to be fulfilled on the Unit when using this Release. */
+    releaseRequirements?: ReleaseRequirements;
+    /** 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?: Record<string, string>;
+    /** Optional. Output only. List of output variables declared on the blueprint and can be present with their values on the unit status */
+    outputVariables?: Array<UnitVariable>;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** Optional. Blueprints are OCI Images that contain all of the artifacts needed to provision a unit. */
+    blueprint?: Blueprint;
+    /** 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;
+    /** Required. Immutable. Reference to the UnitKind this Release corresponds to (required and immutable once created). */
+    unitKind?: string;
+    /** Optional. Output only. List of input variables declared on the blueprint and can be present with their values on the unit spec */
+    inputVariables?: Array<UnitVariable>;
+    /** 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;
+    /** Optional. Mapping of input variables to default values. Maximum 100 */
+    inputVariableDefaults?: Array<UnitVariable>;
+    /** 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;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/releases/{release}" */
+    name?: string;
+}
+export declare const Release: Schema.Schema<Release>;
+export interface UnitDependency {
+    /** Output only. A reference to the Unit object. */
+    unit?: string;
+    /** Output only. Alias for the name of the dependency. */
+    alias?: string;
+}
+export declare const UnitDependency: Schema.Schema<UnitDependency>;
+export interface ListSaasResponse {
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+    /** The resulting saas. */
+    saas?: Array<Saas>;
+    /** 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;
+}
+export declare const ListSaasResponse: Schema.Schema<ListSaasResponse>;
+export interface RunRolloutActionParams {
+    /** Required. If true, the rollout will retry failed operations when resumed. This is applicable only the current state of the Rollout is PAUSED and the requested action is RUN. */
+    retryFailedOperations?: boolean;
+}
+export declare const RunRolloutActionParams: Schema.Schema<RunRolloutActionParams>;
+export interface RolloutControl {
+    /** Optional. Parameters for the RUN action. It is an error to specify this if the RolloutAction is not set to RUN. By default, the rollout will retry failed operations when resumed. */
+    runParams?: RunRolloutActionParams;
+    /** Required. Action to be performed on the Rollout. The default behavior is to run the rollout until it naturally reaches a terminal state. */
+    action?: "ROLLOUT_ACTION_UNSPECIFIED" | "ROLLOUT_ACTION_RUN" | "ROLLOUT_ACTION_PAUSE" | "ROLLOUT_ACTION_CANCEL" | (string & {});
+}
+export declare const RolloutControl: Schema.Schema<RolloutControl>;
+export interface Aggregate {
+    /** Required. Group by which to aggregate. */
+    group?: string;
+    /** Required. Number of records in the group. */
+    count?: number;
+}
+export declare const Aggregate: Schema.Schema<Aggregate>;
+export interface RolloutStats {
+    /** Optional. Output only. Unordered list. A breakdown of the progress of operations triggered by the rollout. Provides a count of Operations by their state. This can be used to determine the number of units which have been updated, or are scheduled to be updated. There will be at most one entry per group. Possible values for operation groups are: - "SCHEDULED" - "PENDING" - "RUNNING" - "SUCCEEDED" - "FAILED" - "CANCELLED" */
+    operationsByState?: Array<Aggregate>;
+}
+export declare const RolloutStats: Schema.Schema<RolloutStats>;
+export interface Rollout {
+    /** 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;
+    /** Optional. Output only. The time when the rollout transitioned into its current state. */
+    stateTransitionTime?: string;
+    /** 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?: RolloutControl;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** Optional. Immutable. Name of the Release that gets rolled out to target Units. Required if no other type of release is specified. */
+    release?: string;
+    /** 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;
+    /** 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;
+    /** 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;
+    /** Optional. Immutable. Name of the RolloutKind this rollout is stemming from and adhering to. */
+    rolloutKind?: string;
+    /** 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;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Output only. Human readable message indicating details about the last state transition. */
+    stateMessage?: string;
+    /** 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?: Record<string, string>;
+    /** Optional. Output only. The time when the rollout started executing. Will be empty if the rollout hasn't started yet. */
+    startTime?: string;
+    /** 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;
+    /** Optional. Output only. Details about the progress of the rollout. */
+    stats?: RolloutStats;
+    /** 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;
+    /** 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;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/rollout/{rollout_id}" */
+    name?: string;
+    /** Output only. The timestamp when the resource was marked for deletion (deletion is an asynchronous operation). */
+    deleteTime?: string;
+    /** Output only. Current state of the rollout. */
+    state?: "ROLLOUT_STATE_UNSPECIFIED" | "ROLLOUT_STATE_RUNNING" | "ROLLOUT_STATE_PAUSED" | "ROLLOUT_STATE_SUCCEEDED" | "ROLLOUT_STATE_FAILED" | "ROLLOUT_STATE_CANCELLED" | "ROLLOUT_STATE_WAITING" | "ROLLOUT_STATE_CANCELLING" | "ROLLOUT_STATE_RESUMING" | "ROLLOUT_STATE_PAUSING" | (string & {});
+    /** 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;
+}
+export declare const Rollout: Schema.Schema<Rollout>;
+export interface 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;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+    /** The resulting rollouts. */
+    rollouts?: Array<Rollout>;
+}
+export declare const ListRolloutsResponse: Schema.Schema<ListRolloutsResponse>;
+export interface Dependency {
+    /** Required. Immutable. The unit kind of the dependency. */
+    unitKind?: string;
+    /** Required. An alias for the dependency. Used for input variable mapping. */
+    alias?: string;
+}
+export declare const Dependency: Schema.Schema<Dependency>;
+export interface Empty {
+}
+export declare const Empty: Schema.Schema<Empty>;
+export interface ToMapping {
+    /** Required. Name of the inputVariable on the dependency */
+    inputVariable?: string;
+    /** Required. Alias of the dependency that the inputVariable will pass its value to */
+    dependency?: string;
+    /** Optional. Tells SaaS Runtime if this mapping should be used during lookup or not */
+    ignoreForLookup?: boolean;
+}
+export declare const ToMapping: Schema.Schema<ToMapping>;
+export interface FromMapping {
+    /** Required. Alias of the dependency that the outputVariable will pass its value to */
+    dependency?: string;
+    /** Required. Name of the outputVariable on the dependency */
+    outputVariable?: string;
+}
+export declare const FromMapping: Schema.Schema<FromMapping>;
+export interface VariableMapping {
+    /** Required. name of the variable */
+    variable?: string;
+    /** Optional. Input variables whose values will be passed on to dependencies. */
+    to?: ToMapping;
+    /** Optional. Output variables which will get their values from dependencies */
+    from?: FromMapping;
+}
+export declare const VariableMapping: Schema.Schema<VariableMapping>;
+export interface CancelOperationRequest {
+}
+export declare const CancelOperationRequest: Schema.Schema<CancelOperationRequest>;
+export interface UnitKind {
+    /** Optional. A reference to the Release object to use as default for creating new units of this UnitKind (optional). If not specified, a new unit must explicitly reference which release to use for its creation. */
+    defaultRelease?: string;
+    /** 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;
+    /** Optional. Immutable. List of other unit kinds that this release will depend on. Dependencies will be automatically provisioned if not found. Maximum 10. */
+    dependencies?: Array<Dependency>;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/unitKinds/{unitKind}" */
+    name?: string;
+    /** 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;
+    /** Optional. List of outputVariables for this unit kind will be passed to this unit's outputVariables. Maximum 100. */
+    outputVariableMappings?: Array<VariableMapping>;
+    /** 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;
+    /** Optional. List of inputVariables for this release that will either be retrieved from a dependency’s outputVariables, or will be passed on to a dependency’s inputVariables. Maximum 100. */
+    inputVariableMappings?: Array<VariableMapping>;
+    /** Required. Immutable. A reference to the Saas that defines the product (managed service) that the producer wants to manage with SaaS Runtime. Part of the SaaS Runtime common data model. Immutable once set. */
+    saas?: string;
+    /** 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?: Record<string, string>;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+}
+export declare const UnitKind: Schema.Schema<UnitKind>;
+export interface ListUnitKindsResponse {
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+    /** The resulting unit kinds. */
+    unitKinds?: Array<UnitKind>;
+    /** 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;
+}
+export declare const ListUnitKindsResponse: Schema.Schema<ListUnitKindsResponse>;
+export interface ListLocationsResponse {
+    /** A list of locations that matches the specified filter in the request. */
+    locations?: Array<GoogleCloudLocationLocation>;
+    /** The standard List next-page token. */
+    nextPageToken?: string;
+}
+export declare const ListLocationsResponse: Schema.Schema<ListLocationsResponse>;
+export interface 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;
+}
+export declare const MaintenanceSettings: Schema.Schema<MaintenanceSettings>;
+export interface Unit {
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Optional. Output only. Indicates the current input variables deployed by the unit */
+    inputVariables?: Array<UnitVariable>;
+    /** Optional. Immutable. Indicates whether the Unit life cycle is controlled by the user or by the system. Immutable once created. */
+    managementMode?: "MANAGEMENT_MODE_UNSPECIFIED" | "MANAGEMENT_MODE_USER" | "MANAGEMENT_MODE_SYSTEM" | (string & {});
+    /** Optional. Output only. If set, indicates the time when the system will start removing the unit. */
+    systemCleanupAt?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/units/{unit}" */
+    name?: string;
+    /** Optional. 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. */
+    maintenance?: MaintenanceSettings;
+    /** Optional. Output only. Indicates the system managed state of the unit. */
+    systemManagedState?: "SYSTEM_MANAGED_STATE_UNSPECIFIED" | "SYSTEM_MANAGED_STATE_ACTIVE" | "SYSTEM_MANAGED_STATE_INACTIVE" | "SYSTEM_MANAGED_STATE_DECOMMISSIONED" | (string & {});
+    /** Optional. Output only. List of concurrent UnitOperations that are operating on this Unit. */
+    ongoingOperations?: Array<string>;
+    /** Optional. Output only. Current lifecycle state of the resource (e.g. if it's being created or ready to use). */
+    state?: "UNIT_STATE_UNSPECIFIED" | "UNIT_STATE_NOT_PROVISIONED" | "UNIT_STATE_PROVISIONING" | "UNIT_STATE_UPDATING" | "UNIT_STATE_DEPROVISIONING" | "UNIT_STATE_READY" | "UNIT_STATE_ERROR" | (string & {});
+    /** Optional. Output only. The current Release object for this Unit. */
+    release?: string;
+    /** Optional. Reference to the Saas Tenant resource this unit belongs to. This for example informs the maintenance policies to use for scheduling future updates on a unit. (optional and immutable once created) */
+    tenant?: string;
+    /** Output only. Indicates whether the resource location satisfies Zone Separation constraints. This is false by default. */
+    satisfiesPzs?: boolean;
+    /** Optional. Reference to the UnitKind this Unit belongs to. Immutable once set. */
+    unitKind?: string;
+    /** Optional. Output only. Set of dependencies for this unit. Maximum 10. */
+    dependencies?: Array<UnitDependency>;
+    /** Optional. Output only. List of scheduled UnitOperations for this unit. */
+    scheduledOperations?: Array<string>;
+    /** Output only. Indicates whether the resource location satisfies Zone Isolation constraints. This is false by default. */
+    satisfiesPzi?: boolean;
+    /** 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;
+    /** 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;
+    /** 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;
+    /** Optional. Output only. List of Units that depend on this unit. Unit can only be deprovisioned if this list is empty. Maximum 1000. */
+    dependents?: Array<UnitDependency>;
+    /** Optional. Output only. List of pending (wait to be executed) UnitOperations for this unit. */
+    pendingOperations?: Array<string>;
+    /** Optional. Output only. A set of conditions which indicate the various conditions this resource can have. */
+    conditions?: Array<UnitCondition>;
+    /** 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?: Record<string, string>;
+    /** Optional. Output only. Set of key/value pairs corresponding to output variables from execution of actuation templates. The variables are declared in actuation configs (e.g in helm chart or terraform) and the values are fetched and returned by the actuation engine upon completion of execution. */
+    outputVariables?: Array<UnitVariable>;
+}
+export declare const Unit: Schema.Schema<Unit>;
+export 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;
+    /** 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?: Record<string, unknown>;
+    /** The error result of the operation in case of failure or cancellation. */
+    error?: Status;
+    /** 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, successful response of the operation. 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?: Record<string, unknown>;
+}
+export declare const Operation: Schema.Schema<Operation>;
+export interface Tenant {
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/tenants/{tenant}" */
+    name?: string;
+    /** Required. Immutable. A reference to the Saas that defines the product (managed service) that the producer wants to manage with SaaS Runtime. Part of the SaaS Runtime common data model. */
+    saas?: string;
+    /** Optional. The labels on the resource, which can be used for categorization. similar to Kubernetes resource labels. */
+    labels?: Record<string, string>;
+    /** 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?: Record<string, string>;
+    /** Output only. The timestamp when the resource was created. */
+    createTime?: string;
+    /** Optional. Immutable. A reference to the consumer resource this SaaS Tenant is representing. The relationship with a consumer resource can be used by SaaS Runtime for retrieving consumer-defined settings and policies such as maintenance policies (using Unified Maintenance Policy API). */
+    consumerResource?: string;
+    /** 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;
+    /** 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;
+    /** 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;
+}
+export declare const Tenant: Schema.Schema<Tenant>;
+export interface 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;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+    /** The resulting tenants. */
+    tenants?: Array<Tenant>;
+}
+export declare const ListTenantsResponse: Schema.Schema<ListTenantsResponse>;
+export interface ListOperationsResponse {
+    /** The standard List next-page token. */
+    nextPageToken?: string;
+    /** A list of operations that matches the specified filter in the request. */
+    operations?: Array<Operation>;
+    /** Unordered list. Unreachable resources. Populated when the request sets `ListOperationsRequest.return_partial_success` and reads across collections. For example, when attempting to list all resources across all supported locations. */
+    unreachable?: Array<string>;
+}
+export declare const ListOperationsResponse: Schema.Schema<ListOperationsResponse>;
+export interface ListRolloutKindsResponse {
+    /** The resulting rollout kinds. */
+    rolloutKinds?: Array<RolloutKind>;
+    /** 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;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+}
+export declare const ListRolloutKindsResponse: Schema.Schema<ListRolloutKindsResponse>;
+export interface 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;
+    /** The resulting units. */
+    units?: Array<Unit>;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+}
+export declare const ListUnitsResponse: Schema.Schema<ListUnitsResponse>;
+export interface 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;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+    /** The resulting unit operations. */
+    unitOperations?: Array<UnitOperation>;
+}
+export declare const ListUnitOperationsResponse: Schema.Schema<ListUnitOperationsResponse>;
+export interface ListReleasesResponse {
+    /** The resulting releases. */
+    releases?: Array<Release>;
+    /** 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;
+    /** Locations that could not be reached. */
+    unreachable?: Array<string>;
+}
+export declare const ListReleasesResponse: Schema.Schema<ListReleasesResponse>;
+export interface GetOperationsRequest {
+    /** The name of the operation resource. */
+    name: string;
+}
+export declare const GetOperationsRequest: Schema.Schema<GetOperationsRequest>;
+export type GetOperationsResponse = Operation;
+export declare const GetOperationsResponse: Schema.Schema<Operation>;
+export type GetOperationsError = DefaultErrors;
+/** 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. */
+export declare const getOperations: API.OperationMethod<GetOperationsRequest, GetOperationsResponse, GetOperationsError, Credentials | HttpClient.HttpClient>;
+export interface CancelOperationsRequest {
+    /** The name of the operation resource to be cancelled. */
+    name: string;
+    /** Request body */
+    body?: CancelOperationRequest;
+}
+export declare const CancelOperationsRequest: Schema.Schema<CancelOperationsRequest>;
+export type CancelOperationsResponse = Empty;
+export declare const CancelOperationsResponse: Schema.Schema<Empty>;
+export type CancelOperationsError = DefaultErrors;
+/** Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`. */
+export declare const cancelOperations: API.OperationMethod<CancelOperationsRequest, CancelOperationsResponse, CancelOperationsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteOperationsRequest {
+    /** The name of the operation resource to be deleted. */
+    name: string;
+}
+export declare const DeleteOperationsRequest: Schema.Schema<DeleteOperationsRequest>;
+export type DeleteOperationsResponse = Empty;
+export declare const DeleteOperationsResponse: Schema.Schema<Empty>;
+export type DeleteOperationsError = DefaultErrors;
+/** Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. */
+export declare const deleteOperations: API.OperationMethod<DeleteOperationsRequest, DeleteOperationsResponse, DeleteOperationsError, Credentials | HttpClient.HttpClient>;
+export interface ListOperationsRequest {
+    /** The standard list page size. */
+    pageSize?: number;
+    /** When set to `true`, operations that are reachable are returned as normal, and those that are unreachable are returned in the ListOperationsResponse.unreachable field. This can only be `true` when reading across collections. For example, when `parent` is set to `"projects/example/locations/-"`. This field is not supported by default and will result in an `UNIMPLEMENTED` error if set unless explicitly documented otherwise in service or product specific documentation. */
+    returnPartialSuccess?: boolean;
+    /** The name of the operation's parent resource. */
+    name: string;
+    /** The standard list page token. */
+    pageToken?: string;
+    /** The standard list filter. */
+    filter?: string;
+}
+export declare const ListOperationsRequest: Schema.Schema<ListOperationsRequest>;
+export type ListOperationsResponse_Op = ListOperationsResponse;
+export declare const ListOperationsResponse_Op: Schema.Schema<ListOperationsResponse>;
+export type ListOperationsError = DefaultErrors;
+/** Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`. */
+export declare const listOperations: API.PaginatedOperationMethod<ListOperationsRequest, ListOperationsResponse_Op, ListOperationsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsRequest {
+    /** A filter to narrow down results to a preferred subset. The filtering language accepts strings like `"displayName=tokyo"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160). */
+    filter?: string;
+    /** The maximum number of results to return. If not set, the service selects a default. */
+    pageSize?: number;
+    /** A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page. */
+    pageToken?: string;
+    /** The resource that owns the locations collection, if applicable. */
+    name: string;
+    /** Optional. Do not use this field. It is unsupported and is ignored unless explicitly documented otherwise. This is primarily for internal usage. */
+    extraLocationTypes?: string[];
+}
+export declare const ListProjectsLocationsRequest: Schema.Schema<ListProjectsLocationsRequest>;
+export type ListProjectsLocationsResponse = ListLocationsResponse;
+export declare const ListProjectsLocationsResponse: Schema.Schema<ListLocationsResponse>;
+export type ListProjectsLocationsError = DefaultErrors;
+/** Lists information about the supported locations for this service. This method can be called in two ways: * **List all public locations:** Use the path `GET /v1/locations`. * **List project-visible locations:** Use the path `GET /v1/projects/{project_id}/locations`. This may include public locations as well as private or other locations specifically visible to the project. */
+export declare const listProjectsLocations: API.PaginatedOperationMethod<ListProjectsLocationsRequest, ListProjectsLocationsResponse, ListProjectsLocationsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsRequest {
+    /** Resource name for the location. */
+    name: string;
+}
+export declare const GetProjectsLocationsRequest: Schema.Schema<GetProjectsLocationsRequest>;
+export type GetProjectsLocationsResponse = GoogleCloudLocationLocation;
+export declare const GetProjectsLocationsResponse: Schema.Schema<GoogleCloudLocationLocation>;
+export type GetProjectsLocationsError = DefaultErrors;
+/** Gets information about a location. */
+export declare const getProjectsLocations: API.OperationMethod<GetProjectsLocationsRequest, GetProjectsLocationsResponse, GetProjectsLocationsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsRolloutKindsRequest {
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/rolloutKinds/{rollout_kind_id}" */
+    name: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Field mask is used to specify the fields to be overwritten in the RolloutKind resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the RolloutKind will be overwritten. */
+    updateMask?: string;
+    /** Request body */
+    body?: RolloutKind;
+}
+export declare const PatchProjectsLocationsRolloutKindsRequest: Schema.Schema<PatchProjectsLocationsRolloutKindsRequest>;
+export type PatchProjectsLocationsRolloutKindsResponse = RolloutKind;
+export declare const PatchProjectsLocationsRolloutKindsResponse: Schema.Schema<RolloutKind>;
+export type PatchProjectsLocationsRolloutKindsError = DefaultErrors;
+/** Update a single rollout kind. */
+export declare const patchProjectsLocationsRolloutKinds: API.OperationMethod<PatchProjectsLocationsRolloutKindsRequest, PatchProjectsLocationsRolloutKindsResponse, PatchProjectsLocationsRolloutKindsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsRolloutKindsRequest {
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** Required. The parent of the rollout kind. */
+    parent: string;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+    /** The maximum number of rollout kinds to send per page. */
+    pageSize?: number;
+}
+export declare const ListProjectsLocationsRolloutKindsRequest: Schema.Schema<ListProjectsLocationsRolloutKindsRequest>;
+export type ListProjectsLocationsRolloutKindsResponse = ListRolloutKindsResponse;
+export declare const ListProjectsLocationsRolloutKindsResponse: Schema.Schema<ListRolloutKindsResponse>;
+export type ListProjectsLocationsRolloutKindsError = DefaultErrors;
+/** Retrieve a collection of rollout kinds. */
+export declare const listProjectsLocationsRolloutKinds: API.PaginatedOperationMethod<ListProjectsLocationsRolloutKindsRequest, ListProjectsLocationsRolloutKindsResponse, ListProjectsLocationsRolloutKindsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsRolloutKindsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsRolloutKindsRequest: Schema.Schema<GetProjectsLocationsRolloutKindsRequest>;
+export type GetProjectsLocationsRolloutKindsResponse = RolloutKind;
+export declare const GetProjectsLocationsRolloutKindsResponse: Schema.Schema<RolloutKind>;
+export type GetProjectsLocationsRolloutKindsError = DefaultErrors;
+/** Retrieve a single rollout kind. */
+export declare const getProjectsLocationsRolloutKinds: API.OperationMethod<GetProjectsLocationsRolloutKindsRequest, GetProjectsLocationsRolloutKindsResponse, GetProjectsLocationsRolloutKindsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsRolloutKindsRequest {
+    /** Required. The ID value for the new rollout kind. */
+    rolloutKindId?: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Required. The parent of the rollout kind. */
+    parent: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Request body */
+    body?: RolloutKind;
+}
+export declare const CreateProjectsLocationsRolloutKindsRequest: Schema.Schema<CreateProjectsLocationsRolloutKindsRequest>;
+export type CreateProjectsLocationsRolloutKindsResponse = RolloutKind;
+export declare const CreateProjectsLocationsRolloutKindsResponse: Schema.Schema<RolloutKind>;
+export type CreateProjectsLocationsRolloutKindsError = DefaultErrors;
+/** Create a new rollout kind. */
+export declare const createProjectsLocationsRolloutKinds: API.OperationMethod<CreateProjectsLocationsRolloutKindsRequest, CreateProjectsLocationsRolloutKindsResponse, CreateProjectsLocationsRolloutKindsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsRolloutKindsRequest {
+    /** The etag known to the client for the expected state of the rollout kind. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the rollout kind. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const DeleteProjectsLocationsRolloutKindsRequest: Schema.Schema<DeleteProjectsLocationsRolloutKindsRequest>;
+export type DeleteProjectsLocationsRolloutKindsResponse = Empty;
+export declare const DeleteProjectsLocationsRolloutKindsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsRolloutKindsError = DefaultErrors;
+/** Delete a single rollout kind. */
+export declare const deleteProjectsLocationsRolloutKinds: API.OperationMethod<DeleteProjectsLocationsRolloutKindsRequest, DeleteProjectsLocationsRolloutKindsResponse, DeleteProjectsLocationsRolloutKindsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsUnitsRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Field mask is used to specify the fields to be overwritten in the Unit resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the Unit will be overwritten. */
+    updateMask?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/units/{unit}" */
+    name: string;
+    /** Request body */
+    body?: Unit;
+}
+export declare const PatchProjectsLocationsUnitsRequest: Schema.Schema<PatchProjectsLocationsUnitsRequest>;
+export type PatchProjectsLocationsUnitsResponse = Unit;
+export declare const PatchProjectsLocationsUnitsResponse: Schema.Schema<Unit>;
+export type PatchProjectsLocationsUnitsError = DefaultErrors;
+/** Update a single unit. */
+export declare const patchProjectsLocationsUnits: API.OperationMethod<PatchProjectsLocationsUnitsRequest, PatchProjectsLocationsUnitsResponse, PatchProjectsLocationsUnitsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsUnitsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** The etag known to the client for the expected state of the unit. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the unit. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+}
+export declare const DeleteProjectsLocationsUnitsRequest: Schema.Schema<DeleteProjectsLocationsUnitsRequest>;
+export type DeleteProjectsLocationsUnitsResponse = Empty;
+export declare const DeleteProjectsLocationsUnitsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsUnitsError = DefaultErrors;
+/** Delete a single unit. */
+export declare const deleteProjectsLocationsUnits: API.OperationMethod<DeleteProjectsLocationsUnitsRequest, DeleteProjectsLocationsUnitsResponse, DeleteProjectsLocationsUnitsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsUnitsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsUnitsRequest: Schema.Schema<GetProjectsLocationsUnitsRequest>;
+export type GetProjectsLocationsUnitsResponse = Unit;
+export declare const GetProjectsLocationsUnitsResponse: Schema.Schema<Unit>;
+export type GetProjectsLocationsUnitsError = DefaultErrors;
+/** Retrieve a single unit. */
+export declare const getProjectsLocationsUnits: API.OperationMethod<GetProjectsLocationsUnitsRequest, GetProjectsLocationsUnitsResponse, GetProjectsLocationsUnitsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsUnitsRequest {
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** The maximum number of units to send per page. */
+    pageSize?: number;
+    /** Required. The parent of the unit. */
+    parent: string;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+}
+export declare const ListProjectsLocationsUnitsRequest: Schema.Schema<ListProjectsLocationsUnitsRequest>;
+export type ListProjectsLocationsUnitsResponse = ListUnitsResponse;
+export declare const ListProjectsLocationsUnitsResponse: Schema.Schema<ListUnitsResponse>;
+export type ListProjectsLocationsUnitsError = DefaultErrors;
+/** Retrieve a collection of units. */
+export declare const listProjectsLocationsUnits: API.PaginatedOperationMethod<ListProjectsLocationsUnitsRequest, ListProjectsLocationsUnitsResponse, ListProjectsLocationsUnitsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsUnitsRequest {
+    /** Required. The ID value for the new unit. */
+    unitId?: string;
+    /** Required. The parent of the unit. */
+    parent: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Request body */
+    body?: Unit;
+}
+export declare const CreateProjectsLocationsUnitsRequest: Schema.Schema<CreateProjectsLocationsUnitsRequest>;
+export type CreateProjectsLocationsUnitsResponse = Unit;
+export declare const CreateProjectsLocationsUnitsResponse: Schema.Schema<Unit>;
+export type CreateProjectsLocationsUnitsError = DefaultErrors;
+/** Create a new unit. */
+export declare const createProjectsLocationsUnits: API.OperationMethod<CreateProjectsLocationsUnitsRequest, CreateProjectsLocationsUnitsResponse, CreateProjectsLocationsUnitsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsUnitOperationsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsUnitOperationsRequest: Schema.Schema<GetProjectsLocationsUnitOperationsRequest>;
+export type GetProjectsLocationsUnitOperationsResponse = UnitOperation;
+export declare const GetProjectsLocationsUnitOperationsResponse: Schema.Schema<UnitOperation>;
+export type GetProjectsLocationsUnitOperationsError = DefaultErrors;
+/** Retrieve a single unit operation. */
+export declare const getProjectsLocationsUnitOperations: API.OperationMethod<GetProjectsLocationsUnitOperationsRequest, GetProjectsLocationsUnitOperationsResponse, GetProjectsLocationsUnitOperationsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsUnitOperationsRequest {
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Field mask is used to specify the fields to be overwritten in the UnitOperation resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the UnitOperation will be overwritten. */
+    updateMask?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/unitOperations/{unitOperation}" */
+    name: string;
+    /** Request body */
+    body?: UnitOperation;
+}
+export declare const PatchProjectsLocationsUnitOperationsRequest: Schema.Schema<PatchProjectsLocationsUnitOperationsRequest>;
+export type PatchProjectsLocationsUnitOperationsResponse = UnitOperation;
+export declare const PatchProjectsLocationsUnitOperationsResponse: Schema.Schema<UnitOperation>;
+export type PatchProjectsLocationsUnitOperationsError = DefaultErrors;
+/** Update a single unit operation. */
+export declare const patchProjectsLocationsUnitOperations: API.OperationMethod<PatchProjectsLocationsUnitOperationsRequest, PatchProjectsLocationsUnitOperationsResponse, PatchProjectsLocationsUnitOperationsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsUnitOperationsRequest {
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Required. The parent of the unit operation. */
+    parent: string;
+    /** Required. The ID value for the new unit operation. */
+    unitOperationId?: string;
+    /** Request body */
+    body?: UnitOperation;
+}
+export declare const CreateProjectsLocationsUnitOperationsRequest: Schema.Schema<CreateProjectsLocationsUnitOperationsRequest>;
+export type CreateProjectsLocationsUnitOperationsResponse = UnitOperation;
+export declare const CreateProjectsLocationsUnitOperationsResponse: Schema.Schema<UnitOperation>;
+export type CreateProjectsLocationsUnitOperationsError = DefaultErrors;
+/** Create a new unit operation. */
+export declare const createProjectsLocationsUnitOperations: API.OperationMethod<CreateProjectsLocationsUnitOperationsRequest, CreateProjectsLocationsUnitOperationsResponse, CreateProjectsLocationsUnitOperationsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsUnitOperationsRequest {
+    /** Required. The parent of the unit operation. */
+    parent: string;
+    /** The maximum number of unit operations to send per page. */
+    pageSize?: number;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+}
+export declare const ListProjectsLocationsUnitOperationsRequest: Schema.Schema<ListProjectsLocationsUnitOperationsRequest>;
+export type ListProjectsLocationsUnitOperationsResponse = ListUnitOperationsResponse;
+export declare const ListProjectsLocationsUnitOperationsResponse: Schema.Schema<ListUnitOperationsResponse>;
+export type ListProjectsLocationsUnitOperationsError = DefaultErrors;
+/** Retrieve a collection of unit operations. */
+export declare const listProjectsLocationsUnitOperations: API.PaginatedOperationMethod<ListProjectsLocationsUnitOperationsRequest, ListProjectsLocationsUnitOperationsResponse, ListProjectsLocationsUnitOperationsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsUnitOperationsRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** The etag known to the client for the expected state of the unit operation. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the unit operation. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const DeleteProjectsLocationsUnitOperationsRequest: Schema.Schema<DeleteProjectsLocationsUnitOperationsRequest>;
+export type DeleteProjectsLocationsUnitOperationsResponse = Empty;
+export declare const DeleteProjectsLocationsUnitOperationsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsUnitOperationsError = DefaultErrors;
+/** Delete a single unit operation. */
+export declare const deleteProjectsLocationsUnitOperations: API.OperationMethod<DeleteProjectsLocationsUnitOperationsRequest, DeleteProjectsLocationsUnitOperationsResponse, DeleteProjectsLocationsUnitOperationsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsReleasesRequest {
+    /** Required. The ID value for the new release. */
+    releaseId?: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Required. The parent of the release. */
+    parent: string;
+    /** Request body */
+    body?: Release;
+}
+export declare const CreateProjectsLocationsReleasesRequest: Schema.Schema<CreateProjectsLocationsReleasesRequest>;
+export type CreateProjectsLocationsReleasesResponse = Release;
+export declare const CreateProjectsLocationsReleasesResponse: Schema.Schema<Release>;
+export type CreateProjectsLocationsReleasesError = DefaultErrors;
+/** Create a new release. */
+export declare const createProjectsLocationsReleases: API.OperationMethod<CreateProjectsLocationsReleasesRequest, CreateProjectsLocationsReleasesResponse, CreateProjectsLocationsReleasesError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsReleasesRequest {
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+    /** The maximum number of releases to send per page. */
+    pageSize?: number;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** Required. The parent of the release. */
+    parent: string;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+}
+export declare const ListProjectsLocationsReleasesRequest: Schema.Schema<ListProjectsLocationsReleasesRequest>;
+export type ListProjectsLocationsReleasesResponse = ListReleasesResponse;
+export declare const ListProjectsLocationsReleasesResponse: Schema.Schema<ListReleasesResponse>;
+export type ListProjectsLocationsReleasesError = DefaultErrors;
+/** Retrieve a collection of releases. */
+export declare const listProjectsLocationsReleases: API.PaginatedOperationMethod<ListProjectsLocationsReleasesRequest, ListProjectsLocationsReleasesResponse, ListProjectsLocationsReleasesError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsReleasesRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsReleasesRequest: Schema.Schema<GetProjectsLocationsReleasesRequest>;
+export type GetProjectsLocationsReleasesResponse = Release;
+export declare const GetProjectsLocationsReleasesResponse: Schema.Schema<Release>;
+export type GetProjectsLocationsReleasesError = DefaultErrors;
+/** Retrieve a single release. */
+export declare const getProjectsLocationsReleases: API.OperationMethod<GetProjectsLocationsReleasesRequest, GetProjectsLocationsReleasesResponse, GetProjectsLocationsReleasesError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsReleasesRequest {
+    /** The etag known to the client for the expected state of the release. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the release. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+}
+export declare const DeleteProjectsLocationsReleasesRequest: Schema.Schema<DeleteProjectsLocationsReleasesRequest>;
+export type DeleteProjectsLocationsReleasesResponse = Empty;
+export declare const DeleteProjectsLocationsReleasesResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsReleasesError = DefaultErrors;
+/** Delete a single release. */
+export declare const deleteProjectsLocationsReleases: API.OperationMethod<DeleteProjectsLocationsReleasesRequest, DeleteProjectsLocationsReleasesResponse, DeleteProjectsLocationsReleasesError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsReleasesRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Field mask is used to specify the fields to be overwritten in the Release resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the Release will be overwritten. */
+    updateMask?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/releases/{release}" */
+    name: string;
+    /** Request body */
+    body?: Release;
+}
+export declare const PatchProjectsLocationsReleasesRequest: Schema.Schema<PatchProjectsLocationsReleasesRequest>;
+export type PatchProjectsLocationsReleasesResponse = Release;
+export declare const PatchProjectsLocationsReleasesResponse: Schema.Schema<Release>;
+export type PatchProjectsLocationsReleasesError = DefaultErrors;
+/** Update a single release. */
+export declare const patchProjectsLocationsReleases: API.OperationMethod<PatchProjectsLocationsReleasesRequest, PatchProjectsLocationsReleasesResponse, PatchProjectsLocationsReleasesError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsUnitKindsRequest {
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** The maximum number of unit kinds to send per page. */
+    pageSize?: number;
+    /** Required. The parent of the unit kind. */
+    parent: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+}
+export declare const ListProjectsLocationsUnitKindsRequest: Schema.Schema<ListProjectsLocationsUnitKindsRequest>;
+export type ListProjectsLocationsUnitKindsResponse = ListUnitKindsResponse;
+export declare const ListProjectsLocationsUnitKindsResponse: Schema.Schema<ListUnitKindsResponse>;
+export type ListProjectsLocationsUnitKindsError = DefaultErrors;
+/** Retrieve a collection of unit kinds. */
+export declare const listProjectsLocationsUnitKinds: API.PaginatedOperationMethod<ListProjectsLocationsUnitKindsRequest, ListProjectsLocationsUnitKindsResponse, ListProjectsLocationsUnitKindsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsUnitKindsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+    /** The etag known to the client for the expected state of the unit kind. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the unit kind. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+}
+export declare const DeleteProjectsLocationsUnitKindsRequest: Schema.Schema<DeleteProjectsLocationsUnitKindsRequest>;
+export type DeleteProjectsLocationsUnitKindsResponse = Empty;
+export declare const DeleteProjectsLocationsUnitKindsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsUnitKindsError = DefaultErrors;
+/** Delete a single unit kind. */
+export declare const deleteProjectsLocationsUnitKinds: API.OperationMethod<DeleteProjectsLocationsUnitKindsRequest, DeleteProjectsLocationsUnitKindsResponse, DeleteProjectsLocationsUnitKindsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsUnitKindsRequest {
+    /** Required. The ID value for the new unit kind. */
+    unitKindId?: string;
+    /** Required. The parent of the unit kind. */
+    parent: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Request body */
+    body?: UnitKind;
+}
+export declare const CreateProjectsLocationsUnitKindsRequest: Schema.Schema<CreateProjectsLocationsUnitKindsRequest>;
+export type CreateProjectsLocationsUnitKindsResponse = UnitKind;
+export declare const CreateProjectsLocationsUnitKindsResponse: Schema.Schema<UnitKind>;
+export type CreateProjectsLocationsUnitKindsError = DefaultErrors;
+/** Create a new unit kind. */
+export declare const createProjectsLocationsUnitKinds: API.OperationMethod<CreateProjectsLocationsUnitKindsRequest, CreateProjectsLocationsUnitKindsResponse, CreateProjectsLocationsUnitKindsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsUnitKindsRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/unitKinds/{unitKind}" */
+    name: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Field mask is used to specify the fields to be overwritten in the UnitKind resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the UnitKind will be overwritten. */
+    updateMask?: string;
+    /** Request body */
+    body?: UnitKind;
+}
+export declare const PatchProjectsLocationsUnitKindsRequest: Schema.Schema<PatchProjectsLocationsUnitKindsRequest>;
+export type PatchProjectsLocationsUnitKindsResponse = UnitKind;
+export declare const PatchProjectsLocationsUnitKindsResponse: Schema.Schema<UnitKind>;
+export type PatchProjectsLocationsUnitKindsError = DefaultErrors;
+/** Update a single unit kind. */
+export declare const patchProjectsLocationsUnitKinds: API.OperationMethod<PatchProjectsLocationsUnitKindsRequest, PatchProjectsLocationsUnitKindsResponse, PatchProjectsLocationsUnitKindsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsUnitKindsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsUnitKindsRequest: Schema.Schema<GetProjectsLocationsUnitKindsRequest>;
+export type GetProjectsLocationsUnitKindsResponse = UnitKind;
+export declare const GetProjectsLocationsUnitKindsResponse: Schema.Schema<UnitKind>;
+export type GetProjectsLocationsUnitKindsError = DefaultErrors;
+/** Retrieve a single unit kind. */
+export declare const getProjectsLocationsUnitKinds: API.OperationMethod<GetProjectsLocationsUnitKindsRequest, GetProjectsLocationsUnitKindsResponse, GetProjectsLocationsUnitKindsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsTenantsRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Required. The ID value for the new tenant. */
+    tenantId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Required. The parent of the tenant. */
+    parent: string;
+    /** Request body */
+    body?: Tenant;
+}
+export declare const CreateProjectsLocationsTenantsRequest: Schema.Schema<CreateProjectsLocationsTenantsRequest>;
+export type CreateProjectsLocationsTenantsResponse = Tenant;
+export declare const CreateProjectsLocationsTenantsResponse: Schema.Schema<Tenant>;
+export type CreateProjectsLocationsTenantsError = DefaultErrors;
+/** Create a new tenant. */
+export declare const createProjectsLocationsTenants: API.OperationMethod<CreateProjectsLocationsTenantsRequest, CreateProjectsLocationsTenantsResponse, CreateProjectsLocationsTenantsError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsTenantsRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** The etag known to the client for the expected state of the tenant. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the tenant. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const DeleteProjectsLocationsTenantsRequest: Schema.Schema<DeleteProjectsLocationsTenantsRequest>;
+export type DeleteProjectsLocationsTenantsResponse = Empty;
+export declare const DeleteProjectsLocationsTenantsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsTenantsError = DefaultErrors;
+/** Delete a single tenant. */
+export declare const deleteProjectsLocationsTenants: API.OperationMethod<DeleteProjectsLocationsTenantsRequest, DeleteProjectsLocationsTenantsResponse, DeleteProjectsLocationsTenantsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsTenantsRequest {
+    /** The maximum number of tenants to send per page. */
+    pageSize?: number;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** Required. The parent of the tenant. */
+    parent: string;
+}
+export declare const ListProjectsLocationsTenantsRequest: Schema.Schema<ListProjectsLocationsTenantsRequest>;
+export type ListProjectsLocationsTenantsResponse = ListTenantsResponse;
+export declare const ListProjectsLocationsTenantsResponse: Schema.Schema<ListTenantsResponse>;
+export type ListProjectsLocationsTenantsError = DefaultErrors;
+/** Retrieve a collection of tenants. */
+export declare const listProjectsLocationsTenants: API.PaginatedOperationMethod<ListProjectsLocationsTenantsRequest, ListProjectsLocationsTenantsResponse, ListProjectsLocationsTenantsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsTenantsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsTenantsRequest: Schema.Schema<GetProjectsLocationsTenantsRequest>;
+export type GetProjectsLocationsTenantsResponse = Tenant;
+export declare const GetProjectsLocationsTenantsResponse: Schema.Schema<Tenant>;
+export type GetProjectsLocationsTenantsError = DefaultErrors;
+/** Retrieve a single tenant. */
+export declare const getProjectsLocationsTenants: API.OperationMethod<GetProjectsLocationsTenantsRequest, GetProjectsLocationsTenantsResponse, GetProjectsLocationsTenantsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsTenantsRequest {
+    /** Field mask is used to specify the fields to be overwritten in the Tenant resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the Tenant will be overwritten. */
+    updateMask?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/tenants/{tenant}" */
+    name: string;
+    /** Request body */
+    body?: Tenant;
+}
+export declare const PatchProjectsLocationsTenantsRequest: Schema.Schema<PatchProjectsLocationsTenantsRequest>;
+export type PatchProjectsLocationsTenantsResponse = Tenant;
+export declare const PatchProjectsLocationsTenantsResponse: Schema.Schema<Tenant>;
+export type PatchProjectsLocationsTenantsError = DefaultErrors;
+/** Update a single tenant. */
+export declare const patchProjectsLocationsTenants: API.OperationMethod<PatchProjectsLocationsTenantsRequest, PatchProjectsLocationsTenantsResponse, PatchProjectsLocationsTenantsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsSaasRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Required. The ID value for the new saas. */
+    saasId?: string;
+    /** Required. The parent of the saas. */
+    parent: string;
+    /** Request body */
+    body?: Saas;
+}
+export declare const CreateProjectsLocationsSaasRequest: Schema.Schema<CreateProjectsLocationsSaasRequest>;
+export type CreateProjectsLocationsSaasResponse = Saas;
+export declare const CreateProjectsLocationsSaasResponse: Schema.Schema<Saas>;
+export type CreateProjectsLocationsSaasError = DefaultErrors;
+/** Create a new saas. */
+export declare const createProjectsLocationsSaas: API.OperationMethod<CreateProjectsLocationsSaasRequest, CreateProjectsLocationsSaasResponse, CreateProjectsLocationsSaasError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsSaasRequest {
+    /** The maximum number of saas to send per page. */
+    pageSize?: number;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+    /** Required. The parent of the saas. */
+    parent: string;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+}
+export declare const ListProjectsLocationsSaasRequest: Schema.Schema<ListProjectsLocationsSaasRequest>;
+export type ListProjectsLocationsSaasResponse = ListSaasResponse;
+export declare const ListProjectsLocationsSaasResponse: Schema.Schema<ListSaasResponse>;
+export type ListProjectsLocationsSaasError = DefaultErrors;
+/** Retrieve a collection of saas. */
+export declare const listProjectsLocationsSaas: API.PaginatedOperationMethod<ListProjectsLocationsSaasRequest, ListProjectsLocationsSaasResponse, ListProjectsLocationsSaasError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsSaasRequest {
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Field mask is used to specify the fields to be overwritten in the Saas resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the Saas will be overwritten. */
+    updateMask?: string;
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/saas/{saas}" */
+    name: string;
+    /** Request body */
+    body?: Saas;
+}
+export declare const PatchProjectsLocationsSaasRequest: Schema.Schema<PatchProjectsLocationsSaasRequest>;
+export type PatchProjectsLocationsSaasResponse = Saas;
+export declare const PatchProjectsLocationsSaasResponse: Schema.Schema<Saas>;
+export type PatchProjectsLocationsSaasError = DefaultErrors;
+/** Update a single saas. */
+export declare const patchProjectsLocationsSaas: API.OperationMethod<PatchProjectsLocationsSaasRequest, PatchProjectsLocationsSaasResponse, PatchProjectsLocationsSaasError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsSaasRequest {
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+    /** The etag known to the client for the expected state of the saas. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the saas. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+}
+export declare const DeleteProjectsLocationsSaasRequest: Schema.Schema<DeleteProjectsLocationsSaasRequest>;
+export type DeleteProjectsLocationsSaasResponse = Empty;
+export declare const DeleteProjectsLocationsSaasResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsSaasError = DefaultErrors;
+/** Delete a single saas. */
+export declare const deleteProjectsLocationsSaas: API.OperationMethod<DeleteProjectsLocationsSaasRequest, DeleteProjectsLocationsSaasResponse, DeleteProjectsLocationsSaasError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsSaasRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsSaasRequest: Schema.Schema<GetProjectsLocationsSaasRequest>;
+export type GetProjectsLocationsSaasResponse = Saas;
+export declare const GetProjectsLocationsSaasResponse: Schema.Schema<Saas>;
+export type GetProjectsLocationsSaasError = DefaultErrors;
+/** Retrieve a single saas. */
+export declare const getProjectsLocationsSaas: API.OperationMethod<GetProjectsLocationsSaasRequest, GetProjectsLocationsSaasResponse, GetProjectsLocationsSaasError, Credentials | HttpClient.HttpClient>;
+export interface DeleteProjectsLocationsRolloutsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** The etag known to the client for the expected state of the rollout. This is used with state-changing methods to prevent accidental overwrites when multiple user agents might be acting in parallel on the same resource. An etag wildcard provide optimistic concurrency based on the expected existence of the rollout. The Any wildcard (`*`) requires that the resource must already exists, and the Not Any wildcard (`!*`) requires that it must not. */
+    etag?: string;
+}
+export declare const DeleteProjectsLocationsRolloutsRequest: Schema.Schema<DeleteProjectsLocationsRolloutsRequest>;
+export type DeleteProjectsLocationsRolloutsResponse = Empty;
+export declare const DeleteProjectsLocationsRolloutsResponse: Schema.Schema<Empty>;
+export type DeleteProjectsLocationsRolloutsError = DefaultErrors;
+/** Delete a single rollout. */
+export declare const deleteProjectsLocationsRollouts: API.OperationMethod<DeleteProjectsLocationsRolloutsRequest, DeleteProjectsLocationsRolloutsResponse, DeleteProjectsLocationsRolloutsError, Credentials | HttpClient.HttpClient>;
+export interface ListProjectsLocationsRolloutsRequest {
+    /** The maximum number of rollouts to send per page. */
+    pageSize?: number;
+    /** Required. The parent of the rollout. */
+    parent: string;
+    /** Filter the list as specified in https://google.aip.dev/160. */
+    filter?: string;
+    /** The page token: If the next_page_token from a previous response is provided, this request will send the subsequent page. */
+    pageToken?: string;
+    /** Order results as specified in https://google.aip.dev/132. */
+    orderBy?: string;
+}
+export declare const ListProjectsLocationsRolloutsRequest: Schema.Schema<ListProjectsLocationsRolloutsRequest>;
+export type ListProjectsLocationsRolloutsResponse = ListRolloutsResponse;
+export declare const ListProjectsLocationsRolloutsResponse: Schema.Schema<ListRolloutsResponse>;
+export type ListProjectsLocationsRolloutsError = DefaultErrors;
+/** Retrieve a collection of rollouts. */
+export declare const listProjectsLocationsRollouts: API.PaginatedOperationMethod<ListProjectsLocationsRolloutsRequest, ListProjectsLocationsRolloutsResponse, ListProjectsLocationsRolloutsError, Credentials | HttpClient.HttpClient>;
+export interface CreateProjectsLocationsRolloutsRequest {
+    /** Required. The ID value for the new rollout. */
+    rolloutId?: string;
+    /** Required. The parent of the rollout. */
+    parent: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** Request body */
+    body?: Rollout;
+}
+export declare const CreateProjectsLocationsRolloutsRequest: Schema.Schema<CreateProjectsLocationsRolloutsRequest>;
+export type CreateProjectsLocationsRolloutsResponse = Rollout;
+export declare const CreateProjectsLocationsRolloutsResponse: Schema.Schema<Rollout>;
+export type CreateProjectsLocationsRolloutsError = DefaultErrors;
+/** Create a new rollout. */
+export declare const createProjectsLocationsRollouts: API.OperationMethod<CreateProjectsLocationsRolloutsRequest, CreateProjectsLocationsRolloutsResponse, CreateProjectsLocationsRolloutsError, Credentials | HttpClient.HttpClient>;
+export interface PatchProjectsLocationsRolloutsRequest {
+    /** Identifier. The resource name (full URI of the resource) following the standard naming scheme: "projects/{project}/locations/{location}/rollout/{rollout_id}" */
+    name: string;
+    /** An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. The server will guarantee that for at least 60 minutes since the first request. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported (00000000-0000-0000-0000-000000000000). */
+    requestId?: string;
+    /** If "validate_only" is set to true, the service will try to validate that this request would succeed, but will not actually make changes. */
+    validateOnly?: boolean;
+    /** Field mask is used to specify the fields to be overwritten in the Rollout resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields in the Rollout will be overwritten. */
+    updateMask?: string;
+    /** Request body */
+    body?: Rollout;
+}
+export declare const PatchProjectsLocationsRolloutsRequest: Schema.Schema<PatchProjectsLocationsRolloutsRequest>;
+export type PatchProjectsLocationsRolloutsResponse = Rollout;
+export declare const PatchProjectsLocationsRolloutsResponse: Schema.Schema<Rollout>;
+export type PatchProjectsLocationsRolloutsError = DefaultErrors;
+/** Update a single rollout. */
+export declare const patchProjectsLocationsRollouts: API.OperationMethod<PatchProjectsLocationsRolloutsRequest, PatchProjectsLocationsRolloutsResponse, PatchProjectsLocationsRolloutsError, Credentials | HttpClient.HttpClient>;
+export interface GetProjectsLocationsRolloutsRequest {
+    /** Required. The resource name of the resource within a service. */
+    name: string;
+}
+export declare const GetProjectsLocationsRolloutsRequest: Schema.Schema<GetProjectsLocationsRolloutsRequest>;
+export type GetProjectsLocationsRolloutsResponse = Rollout;
+export declare const GetProjectsLocationsRolloutsResponse: Schema.Schema<Rollout>;
+export type GetProjectsLocationsRolloutsError = DefaultErrors;
+/** Retrieve a single rollout. */
+export declare const getProjectsLocationsRollouts: API.OperationMethod<GetProjectsLocationsRolloutsRequest, GetProjectsLocationsRolloutsResponse, GetProjectsLocationsRolloutsError, Credentials | HttpClient.HttpClient>;
+//# sourceMappingURL=saasservicemgmt-v1.d.ts.map