googleapis
Version:
Google APIs Client Library for Node.js
909 lines • 62.2 kB
TypeScript
/**
* Copyright 2019 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { OAuth2Client, JWT, Compute, UserRefreshClient } from 'google-auth-library';
import { GoogleConfigurable, MethodOptions, GlobalOptions, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { GaxiosPromise } from 'gaxios';
export declare namespace datafusion_v1beta1 {
interface Options extends GlobalOptions {
version: 'v1beta1';
}
interface StandardParameters {
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Cloud Data Fusion API
*
* Cloud Data Fusion is a fully-managed, cloud native, enterprise data integration service for quickly building and managing data pipelines. It provides a graphical interface to increase time efficiency and reduce complexity, and allows business users, developers, and data scientists to easily and reliably build scalable data integration solutions to cleanse, prepare, blend, transfer and transform data without having to wrestle with infrastructure.
*
* @example
* const {google} = require('googleapis');
* const datafusion = google.datafusion('v1beta1');
*
* @namespace datafusion
* @type {Function}
* @version v1beta1
* @variation v1beta1
* @param {object=} options Options for Datafusion
*/
class Datafusion {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices" "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:foo@gmail.com" ] }, { "log_type": "DATA_WRITE", }, { "log_type": "ADMIN_READ", } ] }, { "service": "fooservice.googleapis.com" "audit_log_configs": [ { "log_type": "DATA_READ", }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:bar@gmail.com" ] } ] } ] } For fooservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts foo@gmail.com from DATA_READ logging, and bar@gmail.com from DATA_WRITE logging.
*/
interface Schema$AuditConfig {
/**
* The configuration for logging of each type of permission.
*/
auditLogConfigs?: Schema$AuditLogConfig[];
exemptedMembers?: string[];
/**
* Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
*/
service?: string;
}
/**
* Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:foo@gmail.com" ] }, { "log_type": "DATA_WRITE", } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting foo@gmail.com from DATA_READ logging.
*/
interface Schema$AuditLogConfig {
/**
* Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
*/
exemptedMembers?: string[];
/**
* The log type that this config enables.
*/
logType?: string;
}
/**
* Authorization-related information used by Cloud Audit Logging.
*/
interface Schema$AuthorizationLoggingOptions {
/**
* The type of the permission that was checked.
*/
permissionType?: string;
}
/**
* Associates `members` with a `role`.
*/
interface Schema$Binding {
/**
* The condition that is associated with this binding. NOTE: An unsatisfied condition will not allow user access via current binding. Different bindings, including their conditions, are examined independently.
*/
condition?: Schema$Expr;
/**
* Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@gmail.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
*/
members?: string[];
/**
* Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
*/
role?: string;
}
/**
* The request message for Operations.CancelOperation.
*/
interface Schema$CancelOperationRequest {
}
/**
* Write a Cloud Audit log
*/
interface Schema$CloudAuditOptions {
/**
* Information used by the Cloud Audit Logging pipeline.
*/
authorizationLoggingOptions?: Schema$AuthorizationLoggingOptions;
/**
* The log_name to populate in the Cloud Audit Record.
*/
logName?: string;
}
/**
* A condition to be met.
*/
interface Schema$Condition {
/**
* Trusted attributes supplied by the IAM system.
*/
iam?: string;
/**
* An operator to apply the subject with.
*/
op?: string;
/**
* Trusted attributes discharged by the service.
*/
svc?: string;
/**
* Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.
*/
sys?: string;
/**
* The objects of the condition.
*/
values?: string[];
}
/**
* Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/backend_debug_access_count {iam_principal=[value of IAMContext.principal]} At this time we do not support multiple field names (though this may be supported in the future).
*/
interface Schema$CounterOptions {
/**
* The field value to attribute.
*/
field?: string;
/**
* The metric to update.
*/
metric?: string;
}
/**
* Write a Data Access (Gin) log
*/
interface Schema$DataAccessOptions {
/**
* Whether Gin logging should happen in a fail-closed manner at the caller. This is relevant only in the LocalIAM implementation, for now.
*/
logMode?: string;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`.
*/
interface Schema$Empty {
}
/**
* Represents an expression text. Example: title: "User account presence" description: "Determines whether the request has a user account" expression: "size(request.user) > 0"
*/
interface Schema$Expr {
/**
* An optional description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
*/
description?: string;
/**
* Textual representation of an expression in Common Expression Language syntax. The application context of the containing message determines which well-known feature set of CEL is supported.
*/
expression?: string;
/**
* An optional string indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
*/
location?: string;
/**
* An optional title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
*/
title?: string;
}
/**
* Represents a Data Fusion instance.
*/
interface Schema$Instance {
/**
* Output only. The time the instance was created.
*/
createTime?: string;
/**
* An optional description of this instance.
*/
description?: string;
/**
* Display name for an instance.
*/
displayName?: string;
/**
* Option to enable Stackdriver Logging.
*/
enableStackdriverLogging?: boolean;
/**
* Option to enable Stackdriver Monitoring.
*/
enableStackdriverMonitoring?: boolean;
/**
* The resource labels for instance to use to annotate any related underlying resources such as GCE VMs. The character '=' is not allowed to be used within the labels.
*/
labels?: {
[key: string]: string;
};
/**
* Output only. The name of this instance is in the form of projects/{project}/locations/{location}/instances/{instance}.
*/
name?: string;
/**
* Network configuration options. These are required when a private Data Fusion instance is to be created.
*/
networkConfig?: Schema$NetworkConfig;
/**
* Map of additional options used to configure the behavior of Data Fusion instance.
*/
options?: {
[key: string]: string;
};
/**
* Specifies whether the Data Fusion instance should be private. If set to true, all Data Fusion nodes will have private IP addresses and will not be able to access the public internet.
*/
privateInstance?: boolean;
/**
* Output only. Service account which will be used to access resources in the customer project."
*/
serviceAccount?: string;
/**
* Output only. Endpoint on which the Data Fusion UI and REST APIs are accessible.
*/
serviceEndpoint?: string;
/**
* Output only. The current state of this Data Fusion instance.
*/
state?: string;
/**
* Output only. Additional information about the current state of this Data Fusion instance if available.
*/
stateMessage?: string;
/**
* Required. Instance type.
*/
type?: string;
/**
* Output only. The time the instance was last updated.
*/
updateTime?: string;
/**
* Output only. Current version of the Data Fusion.
*/
version?: string;
/**
* Name of the zone in which the Data Fusion instance will be created.
*/
zone?: string;
}
/**
* Response message for the list instance request.
*/
interface Schema$ListInstancesResponse {
/**
* Represents a list of Data Fusion instances.
*/
instances?: Schema$Instance[];
/**
* Token to retrieve the next page of results or empty if there are no more results in the list.
*/
nextPageToken?: string;
/**
* Locations that could not be reached.
*/
unreachable?: string[];
}
/**
* The response message for Locations.ListLocations.
*/
interface Schema$ListLocationsResponse {
/**
* A list of locations that matches the specified filter in the request.
*/
locations?: Schema$Location[];
/**
* The standard List next-page token.
*/
nextPageToken?: string;
}
/**
* The response message for Operations.ListOperations.
*/
interface Schema$ListOperationsResponse {
/**
* The standard List next-page token.
*/
nextPageToken?: string;
/**
* A list of operations that matches the specified filter in the request.
*/
operations?: Schema$Operation[];
}
/**
* A resource that represents Google Cloud Platform location.
*/
interface Schema$Location {
/**
* The friendly name for this location, typically a nearby city name. For example, "Tokyo".
*/
displayName?: string;
/**
* Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"}
*/
labels?: {
[key: string]: string;
};
/**
* The canonical id for this location. For example: `"us-east1"`.
*/
locationId?: string;
/**
* Service-specific metadata. For example the available capacity at the given location.
*/
metadata?: {
[key: string]: any;
};
/**
* Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
*/
name?: string;
}
/**
* Specifies what kind of log the caller must write
*/
interface Schema$LogConfig {
/**
* Cloud audit options.
*/
cloudAudit?: Schema$CloudAuditOptions;
/**
* Counter options.
*/
counter?: Schema$CounterOptions;
/**
* Data access options.
*/
dataAccess?: Schema$DataAccessOptions;
}
/**
* Network configuration for a Data Fusion instance. These configurations are used for peering with the customer network. Configurations are optional when a public Data Fusion instance is to be created. However, providing these configurations allows several benefits, such as reduced network latency while accessing the customer resources from managed Data Fusion instance nodes, as well as access to the customer on-prem resources.
*/
interface Schema$NetworkConfig {
/**
* The IP range in CIDR notation to use for the managed Data Fusion instance nodes. This range must not overlap with any other ranges used in the Data Fusion instance network.
*/
ipAllocation?: string;
/**
* Name of the network in the customer project with which the Tenant Project will be peered for executing pipelines.
*/
network?: string;
}
/**
* This resource represents a long-running operation that is the result of a network API call.
*/
interface Schema$Operation {
/**
* If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.
*/
done?: boolean;
/**
* The error result of the operation in case of failure or cancellation.
*/
error?: Schema$Status;
/**
* Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata. Any method that returns a long-running operation should document the metadata type, if any.
*/
metadata?: {
[key: string]: any;
};
/**
* The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.
*/
name?: string;
/**
* The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
*/
response?: {
[key: string]: any;
};
}
/**
* Represents the metadata of a long-running operation.
*/
interface Schema$OperationMetadata {
/**
* API version used to start the operation.
*/
apiVersion?: string;
/**
* The time the operation was created.
*/
createTime?: string;
/**
* The time the operation finished running.
*/
endTime?: string;
/**
* Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
*/
requestedCancellation?: boolean;
/**
* Human-readable status of the operation if any.
*/
statusDetail?: string;
/**
* Server-defined resource path for the target of the operation.
*/
target?: string;
/**
* Name of the verb executed by the operation.
*/
verb?: string;
}
/**
* Defines an Identity and Access Management (IAM) policy. It is used to specify access control policies for Cloud Platform resources. A `Policy` consists of a list of `bindings`. A `binding` binds a list of `members` to a `role`, where the members can be user accounts, Google groups, Google domains, and service accounts. A `role` is a named list of permissions defined by IAM. **JSON Example** { "bindings": [ { "role": "roles/owner", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-other-app@appspot.gserviceaccount.com" ] }, { "role": "roles/viewer", "members": ["user:sean@example.com"] } ] } **YAML Example** bindings: - members: - user:mike@example.com - group:admins@example.com - domain:google.com - serviceAccount:my-other-app@appspot.gserviceaccount.com role: roles/owner - members: - user:sean@example.com role: roles/viewer For a description of IAM and its features, see the [IAM developer's guide](https://cloud.google.com/iam/docs).
*/
interface Schema$Policy {
/**
* Specifies cloud audit logging configuration for this policy.
*/
auditConfigs?: Schema$AuditConfig[];
/**
* Associates a list of `members` to a `role`. `bindings` with no members will result in an error.
*/
bindings?: Schema$Binding[];
/**
* `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. If no `etag` is provided in the call to `setIamPolicy`, then the existing policy is overwritten blindly.
*/
etag?: string;
iamOwned?: boolean;
/**
* If more than one rule is specified, the rules are applied in the following manner: - All matching LOG rules are always applied. - If any DENY/DENY_WITH_LOG rule matches, permission is denied. Logging will be applied if one or more matching rule requires logging. - Otherwise, if any ALLOW/ALLOW_WITH_LOG rule matches, permission is granted. Logging will be applied if one or more matching rule requires logging. - Otherwise, if no rule applies, permission is denied.
*/
rules?: Schema$Rule[];
/**
* Deprecated.
*/
version?: number;
}
/**
* Request message for restarting a Data Fusion instance.
*/
interface Schema$RestartInstanceRequest {
}
/**
* A rule to be applied in a Policy.
*/
interface Schema$Rule {
/**
* Required
*/
action?: string;
/**
* Additional restrictions that must be met. All conditions must pass for the rule to match.
*/
conditions?: Schema$Condition[];
/**
* Human-readable description of the rule.
*/
description?: string;
/**
* If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.
*/
in?: string[];
/**
* The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.
*/
logConfig?: Schema$LogConfig[];
/**
* If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).
*/
notIn?: string[];
/**
* A permission is a string of form '<service>.<resource type>.<verb>' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.
*/
permissions?: string[];
}
/**
* Request message for `SetIamPolicy` method.
*/
interface Schema$SetIamPolicyRequest {
/**
* REQUIRED: The complete policy to be applied to the `resource`. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Cloud Platform services (such as Projects) might reject them.
*/
policy?: Schema$Policy;
/**
* OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: paths: "bindings, etag" This field is only used by Cloud IAM.
*/
updateMask?: string;
}
/**
* The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).
*/
interface Schema$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<{
[key: string]: any;
}>;
/**
* A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client.
*/
message?: string;
}
/**
* Request message for `TestIamPermissions` method.
*/
interface Schema$TestIamPermissionsRequest {
/**
* The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
*/
permissions?: string[];
}
/**
* Response message for `TestIamPermissions` method.
*/
interface Schema$TestIamPermissionsResponse {
/**
* A subset of `TestPermissionsRequest.permissions` that the caller is allowed.
*/
permissions?: string[];
}
/**
* Request message for upgrading a Data Fusion instance. To change the instance properties, instance update should be used.
*/
interface Schema$UpgradeInstanceRequest {
}
class Resource$Projects {
context: APIRequestContext;
locations: Resource$Projects$Locations;
constructor(context: APIRequestContext);
}
class Resource$Projects$Locations {
context: APIRequestContext;
instances: Resource$Projects$Locations$Instances;
operations: Resource$Projects$Locations$Operations;
constructor(context: APIRequestContext);
/**
* datafusion.projects.locations.get
* @desc Gets information about a location.
* @alias datafusion.projects.locations.get
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name Resource name for the location.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
get(params?: Params$Resource$Projects$Locations$Get, options?: MethodOptions): GaxiosPromise<Schema$Location>;
get(params: Params$Resource$Projects$Locations$Get, options: MethodOptions | BodyResponseCallback<Schema$Location>, callback: BodyResponseCallback<Schema$Location>): void;
get(params: Params$Resource$Projects$Locations$Get, callback: BodyResponseCallback<Schema$Location>): void;
get(callback: BodyResponseCallback<Schema$Location>): void;
/**
* datafusion.projects.locations.list
* @desc Lists information about the supported locations for this service.
* @alias datafusion.projects.locations.list
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string=} params.filter The standard list filter.
* @param {string} params.name The resource that owns the locations collection, if applicable.
* @param {integer=} params.pageSize The standard list page size.
* @param {string=} params.pageToken The standard list page token.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
list(params?: Params$Resource$Projects$Locations$List, options?: MethodOptions): GaxiosPromise<Schema$ListLocationsResponse>;
list(params: Params$Resource$Projects$Locations$List, options: MethodOptions | BodyResponseCallback<Schema$ListLocationsResponse>, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
list(params: Params$Resource$Projects$Locations$List, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
list(callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
}
interface Params$Resource$Projects$Locations$Get extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* Resource name for the location.
*/
name?: string;
}
interface Params$Resource$Projects$Locations$List extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* The standard list filter.
*/
filter?: string;
/**
* The resource that owns the locations collection, if applicable.
*/
name?: string;
/**
* The standard list page size.
*/
pageSize?: number;
/**
* The standard list page token.
*/
pageToken?: string;
}
class Resource$Projects$Locations$Instances {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* datafusion.projects.locations.instances.create
* @desc Creates a new Data Fusion instance in the specified project and location.
* @alias datafusion.projects.locations.instances.create
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string=} params.instanceId The name of the instance to create.
* @param {string} params.parent The instance's project and location in the format projects/{project}/locations/{location}.
* @param {().Instance} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
create(params?: Params$Resource$Projects$Locations$Instances$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
create(params: Params$Resource$Projects$Locations$Instances$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
create(params: Params$Resource$Projects$Locations$Instances$Create, callback: BodyResponseCallback<Schema$Operation>): void;
create(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* datafusion.projects.locations.instances.delete
* @desc Deletes a single Date Fusion instance.
* @alias datafusion.projects.locations.instances.delete
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name The instance resource name in the format projects/{project}/locations/{location}/instances/{instance}
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
delete(params?: Params$Resource$Projects$Locations$Instances$Delete, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
delete(params: Params$Resource$Projects$Locations$Instances$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
delete(params: Params$Resource$Projects$Locations$Instances$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
delete(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* datafusion.projects.locations.instances.get
* @desc Gets details of a single Data Fusion instance.
* @alias datafusion.projects.locations.instances.get
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name The instance resource name in the format projects/{project}/locations/{location}/instances/{instance}.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
get(params?: Params$Resource$Projects$Locations$Instances$Get, options?: MethodOptions): GaxiosPromise<Schema$Instance>;
get(params: Params$Resource$Projects$Locations$Instances$Get, options: MethodOptions | BodyResponseCallback<Schema$Instance>, callback: BodyResponseCallback<Schema$Instance>): void;
get(params: Params$Resource$Projects$Locations$Instances$Get, callback: BodyResponseCallback<Schema$Instance>): void;
get(callback: BodyResponseCallback<Schema$Instance>): void;
/**
* datafusion.projects.locations.instances.getIamPolicy
* @desc Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
* @alias datafusion.projects.locations.instances.getIamPolicy
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.resource_ REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
getIamPolicy(params?: Params$Resource$Projects$Locations$Instances$Getiampolicy, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
getIamPolicy(params: Params$Resource$Projects$Locations$Instances$Getiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
getIamPolicy(params: Params$Resource$Projects$Locations$Instances$Getiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
getIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
/**
* datafusion.projects.locations.instances.list
* @desc Lists Data Fusion instances in the specified project and location.
* @alias datafusion.projects.locations.instances.list
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string=} params.filter List filter.
* @param {string=} params.orderBy Sort results. Supported values are "name", "name desc", or "" (unsorted).
* @param {integer=} params.pageSize The maximum number of items to return.
* @param {string=} params.pageToken The next_page_token value to use if there are additional results to retrieve for this list request.
* @param {string} params.parent The project and location for which to retrieve instance information in the format projects/{project}/locations/{location}. If the location is specified as '-' (wildcard), then all regions available to the project are queried, and the results are aggregated.
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
list(params?: Params$Resource$Projects$Locations$Instances$List, options?: MethodOptions): GaxiosPromise<Schema$ListInstancesResponse>;
list(params: Params$Resource$Projects$Locations$Instances$List, options: MethodOptions | BodyResponseCallback<Schema$ListInstancesResponse>, callback: BodyResponseCallback<Schema$ListInstancesResponse>): void;
list(params: Params$Resource$Projects$Locations$Instances$List, callback: BodyResponseCallback<Schema$ListInstancesResponse>): void;
list(callback: BodyResponseCallback<Schema$ListInstancesResponse>): void;
/**
* datafusion.projects.locations.instances.patch
* @desc Updates a single Data Fusion instance.
* @alias datafusion.projects.locations.instances.patch
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name Output only. The name of this instance is in the form of projects/{project}/locations/{location}/instances/{instance}.
* @param {string=} params.updateMask Field mask is used to specify the fields that the update will overwrite in an instance resource. 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, all the supported fields (labels and options currently) will be overwritten.
* @param {().Instance} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
patch(params?: Params$Resource$Projects$Locations$Instances$Patch, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
patch(params: Params$Resource$Projects$Locations$Instances$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
patch(params: Params$Resource$Projects$Locations$Instances$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
patch(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* datafusion.projects.locations.instances.restart
* @desc Restart a single Data Fusion instance. At the end of an operation instance is fully restarted.
* @alias datafusion.projects.locations.instances.restart
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name Name of the Data Fusion instance which need to be restarted in the form of projects/{project}/locations/{location}/instances/{instance}
* @param {().RestartInstanceRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
restart(params?: Params$Resource$Projects$Locations$Instances$Restart, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
restart(params: Params$Resource$Projects$Locations$Instances$Restart, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
restart(params: Params$Resource$Projects$Locations$Instances$Restart, callback: BodyResponseCallback<Schema$Operation>): void;
restart(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* datafusion.projects.locations.instances.setIamPolicy
* @desc Sets the access control policy on the specified resource. Replaces any existing policy.
* @alias datafusion.projects.locations.instances.setIamPolicy
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.resource_ REQUIRED: The resource for which the policy is being specified. See the operation documentation for the appropriate value for this field.
* @param {().SetIamPolicyRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
setIamPolicy(params?: Params$Resource$Projects$Locations$Instances$Setiampolicy, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
setIamPolicy(params: Params$Resource$Projects$Locations$Instances$Setiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
setIamPolicy(params: Params$Resource$Projects$Locations$Instances$Setiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
setIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
/**
* datafusion.projects.locations.instances.testIamPermissions
* @desc Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a NOT_FOUND error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
* @alias datafusion.projects.locations.instances.testIamPermissions
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.resource_ REQUIRED: The resource for which the policy detail is being requested. See the operation documentation for the appropriate value for this field.
* @param {().TestIamPermissionsRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
testIamPermissions(params?: Params$Resource$Projects$Locations$Instances$Testiampermissions, options?: MethodOptions): GaxiosPromise<Schema$TestIamPermissionsResponse>;
testIamPermissions(params: Params$Resource$Projects$Locations$Instances$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
testIamPermissions(params: Params$Resource$Projects$Locations$Instances$Testiampermissions, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
testIamPermissions(callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
/**
* datafusion.projects.locations.instances.upgrade
* @desc Upgrade a single Data Fusion instance. At the end of an operation instance is fully upgraded.
* @alias datafusion.projects.locations.instances.upgrade
* @memberOf! ()
*
* @param {object} params Parameters for request
* @param {string} params.name Name of the Data Fusion instance which need to be upgraded in the form of projects/{project}/locations/{location}/instances/{instance} Instance will be upgraded with the latest stable version of the Data Fusion.
* @param {().UpgradeInstanceRequest} params.resource Request body data
* @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
* @param {callback} callback The callback that handles the response.
* @return {object} Request object
*/
upgrade(params?: Params$Resource$Projects$Locations$Instances$Upgrade, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
upgrade(params: Params$Resource$Projects$Locations$Instances$Upgrade, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
upgrade(params: Params$Resource$Projects$Locations$Instances$Upgrade, callback: BodyResponseCallback<Schema$Operation>): void;
upgrade(callback: BodyResponseCallback<Schema$Operation>): void;
}
interface Params$Resource$Projects$Locations$Instances$Create extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* The name of the instance to create.
*/
instanceId?: string;
/**
* The instance's project and location in the format projects/{project}/locations/{location}.
*/
parent?: string;
/**
* Request body metadata
*/
requestBody?: Schema$Instance;
}
interface Params$Resource$Projects$Locations$Instances$Delete extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* The instance resource name in the format projects/{project}/locations/{location}/instances/{instance}
*/
name?: string;
}
interface Params$Resource$Projects$Locations$Instances$Get extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* The instance resource name in the format projects/{project}/locations/{location}/instances/{instance}.
*/
name?: string;
}
interface Params$Resource$Projects$Locations$Instances$Getiampolicy extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* REQUIRED: The resource for which the policy is being requested. See the operation documentation for the appropriate value for this field.
*/
resource?: string;
}
interface Params$Resource$Projects$Locations$Instances$List extends StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
/**
* List filter.
*/
filter?: string;
/**
* Sort results. Supp