googleapis
Version:
Google APIs Client Library for Node.js
1,204 lines • 111 kB
TypeScript
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace looker_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Looker (Google Cloud core) API
*
*
*
* @example
* ```js
* const {google} = require('googleapis');
* const looker = google.looker('v1');
* ```
*/
export class Looker {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Looker instance Admin settings fields.
*/
export interface Schema$AdminSettings {
/**
* Email domain allowlist for the instance.
*/
allowedEmailDomains?: string[] | null;
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Controlled egress configuration.
*/
export interface Schema$ControlledEgressConfig {
/**
* Optional. List of fully qualified domain names to be added to the allowlist for outbound traffic.
*/
egressFqdns?: string[] | null;
/**
* Optional. Whether marketplace is enabled.
*/
marketplaceEnabled?: boolean | null;
/**
* Output only. The list of IP addresses used by Secure Web Proxy for outbound traffic.
*/
webProxyIps?: string[] | null;
}
/**
* Custom domain information.
*/
export interface Schema$CustomDomain {
/**
* Domain name.
*/
domain?: string | null;
/**
* Domain state.
*/
state?: string | null;
}
/**
* Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp
*/
export interface Schema$Date {
/**
* Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant.
*/
day?: number | null;
/**
* Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day.
*/
month?: number | null;
/**
* Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.
*/
year?: number | null;
}
/**
* Specifies the maintenance denial period.
*/
export interface Schema$DenyMaintenancePeriod {
/**
* Required. End date of the deny maintenance period.
*/
endDate?: Schema$Date;
/**
* Required. Start date of the deny maintenance period.
*/
startDate?: Schema$Date;
/**
* Required. Time in UTC when the period starts and ends.
*/
time?: Schema$TimeOfDay;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
*/
export interface Schema$Empty {
}
/**
* Encryption configuration (i.e. CMEK).
*/
export interface Schema$EncryptionConfig {
/**
* Name of the CMEK key in KMS (input parameter).
*/
kmsKeyName?: string | null;
/**
* Output only. Full name and version of the CMEK key currently in use to encrypt Looker data. Format: `projects/{project\}/locations/{location\}/keyRings/{ring\}/cryptoKeys/{key\}/cryptoKeyVersions/{version\}`. Empty if CMEK is not configured in this instance.
*/
kmsKeyNameVersion?: string | null;
/**
* Output only. Status of the CMEK key.
*/
kmsKeyState?: string | null;
}
/**
* Configuration for Encryption - e.g. CMEK.
*/
export interface Schema$ExportEncryptionConfig {
/**
* Required. Name of the CMEK key in KMS.
*/
kmsKeyName?: string | null;
}
/**
* Request options for exporting data of an Instance.
*/
export interface Schema$ExportInstanceRequest {
/**
* Required. Encryption configuration (CMEK). For CMEK enabled instances it should be same as looker CMEK.
*/
encryptionConfig?: Schema$ExportEncryptionConfig;
/**
* The path to the folder in Google Cloud Storage where the export will be stored. The URI is in the form `gs://bucketName/folderName`.
*/
gcsUri?: string | null;
}
/**
* ExportMetadata represents the metadata of the exported artifacts. The metadata.json file in export artifact can be parsed as this message
*/
export interface Schema$ExportMetadata {
/**
* Encryption key that was used to encrypt the export artifacts.
*/
exportEncryptionKey?: Schema$ExportMetadataEncryptionKey;
/**
* List of files created as part of export artifact (excluding the metadata). The paths are relative to the folder containing the metadata.
*/
filePaths?: string[] | null;
/**
* Looker encryption key, encrypted with the provided export encryption key. This value will only be populated if the looker instance uses Looker managed encryption instead of CMEK.
*/
lookerEncryptionKey?: string | null;
/**
* Name of the exported instance. Format: projects/{project\}/locations/{location\}/instances/{instance\}
*/
lookerInstance?: string | null;
/**
* Platform edition of the exported instance.
*/
lookerPlatformEdition?: string | null;
/**
* Version of instance when the export was created.
*/
lookerVersion?: string | null;
/**
* The source type of the migration.
*/
source?: string | null;
}
/**
* Encryption key details for the exported artifact.
*/
export interface Schema$ExportMetadataEncryptionKey {
/**
* Name of the CMEK.
*/
cmek?: string | null;
/**
* Version of the CMEK.
*/
version?: string | null;
}
/**
* Requestion options for importing looker data to an Instance
*/
export interface Schema$ImportInstanceRequest {
/**
* Path to the import folder in Google Cloud Storage, in the form `gs://bucketName/folderName`.
*/
gcsUri?: string | null;
}
/**
* A Looker instance.
*/
export interface Schema$Instance {
/**
* Looker Instance Admin settings.
*/
adminSettings?: Schema$AdminSettings;
/**
* Optional. Indicates whether catalog integration is enabled for the Looker instance.
*/
catalogIntegrationEnabled?: boolean | null;
/**
* Optional. Storage class of the instance.
*/
classType?: string | null;
/**
* Network name in the consumer project. Format: `projects/{project\}/global/networks/{network\}`. Note that the consumer network may be in a different GCP project than the consumer project that is hosting the Looker Instance.
*/
consumerNetwork?: string | null;
/**
* Optional. Controlled egress configuration.
*/
controlledEgressConfig?: Schema$ControlledEgressConfig;
/**
* Optional. Whether controlled egress is enabled on the Looker instance.
*/
controlledEgressEnabled?: boolean | null;
/**
* Output only. The time when the Looker instance provisioning was first requested.
*/
createTime?: string | null;
/**
* Custom domain configuration for the instance.
*/
customDomain?: Schema$CustomDomain;
/**
* Maintenance denial period for this instance.
*/
denyMaintenancePeriod?: Schema$DenyMaintenancePeriod;
/**
* Output only. Public Egress IP (IPv4).
*/
egressPublicIp?: string | null;
/**
* Encryption configuration (CMEK). Only set if CMEK has been enabled on the instance.
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Optional. Whether FIPS is enabled on the Looker instance.
*/
fipsEnabled?: boolean | null;
/**
* Optional. Whether Gemini feature is enabled on the Looker instance or not.
*/
geminiEnabled?: boolean | null;
/**
* Output only. Private Ingress IP (IPv4).
*/
ingressPrivateIp?: string | null;
/**
* Output only. Public Ingress IP (IPv4).
*/
ingressPublicIp?: string | null;
/**
* Output only. Last computed maintenance denial period for this instance.
*/
lastDenyMaintenancePeriod?: Schema$DenyMaintenancePeriod;
/**
* Optional. Linked Google Cloud Project Number for Looker Studio Pro.
*/
linkedLspProjectNumber?: string | null;
/**
* Output only. Looker instance URI which can be used to access the Looker Instance UI.
*/
lookerUri?: string | null;
/**
* Output only. The Looker version that the instance is using.
*/
lookerVersion?: string | null;
/**
* Maintenance schedule for this instance.
*/
maintenanceSchedule?: Schema$MaintenanceSchedule;
/**
* Maintenance window for this instance.
*/
maintenanceWindow?: Schema$MaintenanceWindow;
/**
* Output only. Format: `projects/{project\}/locations/{location\}/instances/{instance\}`.
*/
name?: string | null;
/**
* Looker instance OAuth login settings.
*/
oauthConfig?: Schema$OAuthConfig;
/**
* Optional. Configuration for periodic export.
*/
periodicExportConfig?: Schema$PeriodicExportConfig;
/**
* Platform edition.
*/
platformEdition?: string | null;
/**
* Whether private IP is enabled on the Looker instance.
*/
privateIpEnabled?: boolean | null;
/**
* Optional. PSC configuration. Used when `psc_enabled` is true.
*/
pscConfig?: Schema$PscConfig;
/**
* Optional. Whether to use Private Service Connect (PSC) for private IP connectivity. If true, neither `public_ip_enabled` nor `private_ip_enabled` can be true.
*/
pscEnabled?: boolean | null;
/**
* Whether public IP is enabled on the Looker instance.
*/
publicIpEnabled?: boolean | null;
/**
* Name of a reserved IP address range within the Instance.consumer_network, to be used for private services access connection. May or may not be specified in a create request.
*/
reservedRange?: string | null;
/**
* Output only. Reserved for future use.
*/
satisfiesPzi?: boolean | null;
/**
* Output only. Reserved for future use.
*/
satisfiesPzs?: boolean | null;
/**
* Output only. The reason for the instance being in a soft-deleted state.
*/
softDeleteReason?: string | null;
/**
* Output only. The state of the instance.
*/
state?: string | null;
/**
* Output only. The time when the Looker instance was suspended (soft deleted).
*/
suspendedTime?: string | null;
/**
* Output only. The time when the Looker instance was last updated.
*/
updateTime?: string | null;
/**
* Optional. User metadata.
*/
userMetadata?: Schema$UserMetadata;
}
/**
* The details of a backup resource.
*/
export interface Schema$InstanceBackup {
/**
* Output only. The time when the backup was started.
*/
createTime?: string | null;
/**
* Output only. Current status of the CMEK encryption
*/
encryptionConfig?: Schema$EncryptionConfig;
/**
* Output only. The time when the backup will be deleted.
*/
expireTime?: string | null;
/**
* Immutable. The relative resource name of the backup, in the following form: `projects/{project_number\}/locations/{location_id\}/instances/{instance_id\}/backups/{backup\}`
*/
name?: string | null;
/**
* Output only. The current state of the backup.
*/
state?: string | null;
}
/**
* Response from listing Looker instance backups.
*/
export interface Schema$ListInstanceBackupsResponse {
/**
* The list of instances matching the request filters, up to the requested `page_size`.
*/
instanceBackups?: Schema$InstanceBackup[];
/**
* If provided, a page token that can look up the next `page_size` results. If empty, the results list is exhausted.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* Response from ListInstances.
*/
export interface Schema$ListInstancesResponse {
/**
* The list of instances matching the request filters, up to the requested ListInstancesRequest.pageSize.
*/
instances?: Schema$Instance[];
/**
* If provided, a page token that can look up the next ListInstancesRequest.pageSize results. If empty, the results list is exhausted.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response message for Locations.ListLocations.
*/
export interface Schema$ListLocationsResponse {
/**
* A list of locations that matches the specified filter in the request.
*/
locations?: Schema$Location[];
/**
* The standard List next-page token.
*/
nextPageToken?: string | null;
}
/**
* The response message for Operations.ListOperations.
*/
export interface Schema$ListOperationsResponse {
/**
* The standard List next-page token.
*/
nextPageToken?: string | null;
/**
* A list of operations that matches the specified filter in the request.
*/
operations?: Schema$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?: string[] | null;
}
/**
* A resource that represents a Google Cloud location.
*/
export interface Schema$Location {
/**
* The friendly name for this location, typically a nearby city name. For example, "Tokyo".
*/
displayName?: string | null;
/**
* Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"\}
*/
labels?: {
[key: string]: string;
} | null;
/**
* The canonical id for this location. For example: `"us-east1"`.
*/
locationId?: string | null;
/**
* Service-specific metadata. For example the available capacity at the given location.
*/
metadata?: {
[key: string]: any;
} | null;
/**
* Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
*/
name?: string | null;
}
/**
* Published upcoming future maintenance schedule.
*/
export interface Schema$MaintenanceSchedule {
/**
* The scheduled end time for the maintenance.
*/
endTime?: string | null;
/**
* The scheduled start time for the maintenance.
*/
startTime?: string | null;
}
/**
* Specifies the recurring maintenance window.
*/
export interface Schema$MaintenanceWindow {
/**
* Required. Day of the week for this MaintenanceWindow (in UTC).
*/
dayOfWeek?: string | null;
/**
* Required. Time in UTC when the period starts. Maintenance will be scheduled within 60 minutes.
*/
startTime?: Schema$TimeOfDay;
}
/**
* Looker instance OAuth login settings.
*/
export interface Schema$OAuthConfig {
/**
* Input only. Client ID from an external OAuth application. This is an input-only field, and thus will not be set in any responses.
*/
clientId?: string | null;
/**
* Input only. Client secret from an external OAuth application. This is an input-only field, and thus will not be set in any responses.
*/
clientSecret?: string | null;
}
/**
* This resource represents a long-running operation that is the result of a network API call.
*/
export 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 | null;
/**
* 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;
} | null;
/**
* 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 | null;
/**
* 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?: {
[key: string]: any;
} | null;
}
/**
* Represents the metadata of the long-running operation.
*/
export interface Schema$OperationMetadata {
/**
* API version used to start the operation.
*/
apiVersion?: string | null;
/**
* The time the operation was created.
*/
createTime?: string | null;
/**
* The time the operation finished running.
*/
endTime?: string | null;
/**
* 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 | null;
/**
* Human-readable status of the operation, if any.
*/
statusMessage?: string | null;
/**
* Server-defined resource path for the target of the operation.
*/
target?: string | null;
/**
* Name of the verb executed by the operation.
*/
verb?: string | null;
}
/**
* Configuration for periodic export.
*/
export interface Schema$PeriodicExportConfig {
/**
* Required. Cloud Storage bucket URI for periodic export. Format: gs://{bucket_name\}
*/
gcsUri?: string | null;
/**
* Required. Name of the CMEK key in KMS. Format: projects/{project\}/locations/{location\}/keyRings/{key_ring\}/cryptoKeys/{crypto_key\}
*/
kmsKey?: string | null;
/**
* Required. Time in UTC to start the periodic export job.
*/
startTime?: Schema$TimeOfDay;
}
/**
* Information for Private Service Connect (PSC) setup for a Looker instance.
*/
export interface Schema$PscConfig {
/**
* Optional. List of VPCs that are allowed ingress into looker. Format: projects/{project\}/global/networks/{network\}
*/
allowedVpcs?: string[] | null;
/**
* Output only. URI of the Looker service attachment.
*/
lookerServiceAttachmentUri?: string | null;
/**
* Optional. List of egress service attachment configurations.
*/
serviceAttachments?: Schema$ServiceAttachment[];
}
/**
* Request options for restarting an instance.
*/
export interface Schema$RestartInstanceRequest {
}
/**
* Request options for restoring an instance
*/
export interface Schema$RestoreInstanceRequest {
/**
* Required. Backup being used to restore the instance Format: projects/{project\}/locations/{location\}/instances/{instance\}/backups/{backup\}
*/
backup?: string | null;
}
/**
* Service attachment configuration.
*/
export interface Schema$ServiceAttachment {
/**
* Output only. Connection status.
*/
connectionStatus?: string | null;
/**
* Output only. Reason the service attachment creation failed. This value will only be populated if the service attachment encounters an issue during provisioning.
*/
failureReason?: string | null;
/**
* Optional. Fully qualified domain name that will be used in the private DNS record created for the service attachment.
*/
localFqdn?: string | null;
/**
* Optional. List of fully qualified domain names that will be used in the private DNS record created for the service attachment.
*/
localFqdns?: string[] | null;
/**
* Required. URI of the service attachment to connect to. Format: projects/{project\}/regions/{region\}/serviceAttachments/{service_attachment\}
*/
targetServiceAttachmentUri?: string | null;
}
/**
* 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).
*/
export interface Schema$Status {
/**
* The status code, which should be an enum value of google.rpc.Code.
*/
code?: number | null;
/**
* 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;
}> | null;
/**
* 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 | null;
}
/**
* Represents a time of day. The date and time zone are either not significant or are specified elsewhere. An API may choose to allow leap seconds. Related types are google.type.Date and `google.protobuf.Timestamp`.
*/
export interface Schema$TimeOfDay {
/**
* Hours of a day in 24 hour format. Must be greater than or equal to 0 and typically must be less than or equal to 23. An API may choose to allow the value "24:00:00" for scenarios like business closing time.
*/
hours?: number | null;
/**
* Minutes of an hour. Must be greater than or equal to 0 and less than or equal to 59.
*/
minutes?: number | null;
/**
* Fractions of seconds, in nanoseconds. Must be greater than or equal to 0 and less than or equal to 999,999,999.
*/
nanos?: number | null;
/**
* Seconds of a minute. Must be greater than or equal to 0 and typically must be less than or equal to 59. An API may allow the value 60 if it allows leap-seconds.
*/
seconds?: number | null;
}
/**
* Request options for undeleting an instance.
*/
export interface Schema$UndeleteInstanceRequest {
}
/**
* Metadata about users for a Looker instance.
*/
export interface Schema$UserMetadata {
/**
* Optional. The number of additional developer users the instance owner has purchased.
*/
additionalDeveloperUserCount?: number | null;
/**
* Optional. The number of additional standard users the instance owner has purchased.
*/
additionalStandardUserCount?: number | null;
/**
* Optional. The number of additional viewer users the instance owner has purchased.
*/
additionalViewerUserCount?: number | null;
}
export class Resource$Projects {
context: APIRequestContext;
locations: Resource$Projects$Locations;
constructor(context: APIRequestContext);
}
export class Resource$Projects$Locations {
context: APIRequestContext;
instances: Resource$Projects$Locations$Instances;
operations: Resource$Projects$Locations$Operations;
constructor(context: APIRequestContext);
/**
* Gets information about a location.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
*
* // Acquire an auth client, and bind it to all future calls
* const authClient = await auth.getClient();
* google.options({auth: authClient});
*
* // Do the magic
* const res = await looker.projects.locations.get({
* // Resource name for the location.
* name: 'projects/my-project/locations/my-location',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "displayName": "my_displayName",
* // "labels": {},
* // "locationId": "my_locationId",
* // "metadata": {},
* // "name": "my_name"
* // }
* }
*
* main().catch(e => {
* console.error(e);
* throw e;
* });
*
* ```
*
* @param params - Parameters for request
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
* @param callback - Optional callback that handles the response.
* @returns A promise if used with async/await, or void if used with a callback.
*/
get(params: Params$Resource$Projects$Locations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
get(params?: Params$Resource$Projects$Locations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Location>>;
get(params: Params$Resource$Projects$Locations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
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;
/**
* Lists information about the supported locations for this service.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
*
* // Acquire an auth client, and bind it to all future calls
* const authClient = await auth.getClient();
* google.options({auth: authClient});
*
* // Do the magic
* const res = await looker.projects.locations.list({
* // Optional. Do not use this field. It is unsupported and is ignored unless explicitly documented otherwise. This is primarily for internal usage.
* extraLocationTypes: 'placeholder-value',
* // 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: 'placeholder-value',
* // The resource that owns the locations collection, if applicable.
* name: 'projects/my-project',
* // The maximum number of results to return. If not set, the service selects a default.
* pageSize: 'placeholder-value',
* // A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
* pageToken: 'placeholder-value',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "locations": [],
* // "nextPageToken": "my_nextPageToken"
* // }
* }
*
* main().catch(e => {
* console.error(e);
* throw e;
* });
*
* ```
*
* @param params - Parameters for request
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
* @param callback - Optional callback that handles the response.
* @returns A promise if used with async/await, or void if used with a callback.
*/
list(params: Params$Resource$Projects$Locations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
list(params?: Params$Resource$Projects$Locations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>;
list(params: Params$Resource$Projects$Locations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
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;
}
export interface Params$Resource$Projects$Locations$Get extends StandardParameters {
/**
* Resource name for the location.
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$List extends StandardParameters {
/**
* Optional. Do not use this field. It is unsupported and is ignored unless explicitly documented otherwise. This is primarily for internal usage.
*/
extraLocationTypes?: string[];
/**
* 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 resource that owns the locations collection, if applicable.
*/
name?: 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;
}
export class Resource$Projects$Locations$Instances {
context: APIRequestContext;
backups: Resource$Projects$Locations$Instances$Backups;
constructor(context: APIRequestContext);
/**
* Creates a new Instance in a given project and location.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
*
* // Acquire an auth client, and bind it to all future calls
* const authClient = await auth.getClient();
* google.options({auth: authClient});
*
* // Do the magic
* const res = await looker.projects.locations.instances.create({
* // Required. The unique instance identifier. Must contain only lowercase letters, numbers, or hyphens, with the first character a letter and the last a letter or a number. 63 characters maximum.
* instanceId: 'placeholder-value',
* // Required. Format: `projects/{project\}/locations/{location\}`.
* parent: 'projects/my-project/locations/my-location',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "adminSettings": {},
* // "catalogIntegrationEnabled": false,
* // "classType": "my_classType",
* // "consumerNetwork": "my_consumerNetwork",
* // "controlledEgressConfig": {},
* // "controlledEgressEnabled": false,
* // "createTime": "my_createTime",
* // "customDomain": {},
* // "denyMaintenancePeriod": {},
* // "egressPublicIp": "my_egressPublicIp",
* // "encryptionConfig": {},
* // "fipsEnabled": false,
* // "geminiEnabled": false,
* // "ingressPrivateIp": "my_ingressPrivateIp",
* // "ingressPublicIp": "my_ingressPublicIp",
* // "lastDenyMaintenancePeriod": {},
* // "linkedLspProjectNumber": "my_linkedLspProjectNumber",
* // "lookerUri": "my_lookerUri",
* // "lookerVersion": "my_lookerVersion",
* // "maintenanceSchedule": {},
* // "maintenanceWindow": {},
* // "name": "my_name",
* // "oauthConfig": {},
* // "periodicExportConfig": {},
* // "platformEdition": "my_platformEdition",
* // "privateIpEnabled": false,
* // "pscConfig": {},
* // "pscEnabled": false,
* // "publicIpEnabled": false,
* // "reservedRange": "my_reservedRange",
* // "satisfiesPzi": false,
* // "satisfiesPzs": false,
* // "softDeleteReason": "my_softDeleteReason",
* // "state": "my_state",
* // "suspendedTime": "my_suspendedTime",
* // "updateTime": "my_updateTime",
* // "userMetadata": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "response": {}
* // }
* }
*
* main().catch(e => {
* console.error(e);
* throw e;
* });
*
* ```
*
* @param params - Parameters for request
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
* @param callback - Optional callback that handles the response.
* @returns A promise if used with async/await, or void if used with a callback.
*/
create(params: Params$Resource$Projects$Locations$Instances$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
create(params?: Params$Resource$Projects$Locations$Instances$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
create(params: Params$Resource$Projects$Locations$Instances$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
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;
/**
* Delete instance.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
*
* // Acquire an auth client, and bind it to all future calls
* const authClient = await auth.getClient();
* google.options({auth: authClient});
*
* // Do the magic
* const res = await looker.projects.locations.instances.delete({
* // Whether to force cascading delete.
* force: 'placeholder-value',
* // Required. Format: `projects/{project\}/locations/{location\}/instances/{instance\}`.
* name: 'projects/my-project/locations/my-location/instances/my-instance',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "response": {}
* // }
* }
*
* main().catch(e => {
* console.error(e);
* throw e;
* });
*
* ```
*
* @param params - Parameters for request
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
* @param callback - Optional callback that handles the response.
* @returns A promise if used with async/await, or void if used with a callback.
*/
delete(params: Params$Resource$Projects$Locations$Instances$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
delete(params?: Params$Resource$Projects$Locations$Instances$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
delete(params: Params$Resource$Projects$Locations$Instances$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
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;
/**
* Export instance.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googleapis.com/auth/cloud-platform'],
* });
*
* // Acquire an auth client, and bind it to all future calls
* const authClient = await auth.getClient();
* google.options({auth: authClient});
*
* // Do the magic
* const res = await looker.projects.locations.instances.export({
* // Required. Format: `projects/{project\}/locations/{location\}/instances/{instance\}`.
* name: 'projects/my-project/locations/my-location/instances/my-instance',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "encryptionConfig": {},
* // "gcsUri": "my_gcsUri"
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "done": false,
* // "error": {},
* // "metadata": {},
* // "name": "my_name",
* // "response": {}
* // }
* }
*
* main().catch(e => {
* console.error(e);
* throw e;
* });
*
* ```
*
* @param params - Parameters for request
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
* @param callback - Optional callback that handles the response.
* @returns A promise if used with async/await, or void if used with a callback.
*/
export(params: Params$Resource$Projects$Locations$Instances$Export, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
export(params?: Params$Resource$Projects$Locations$Instances$Export, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
export(params: Params$Resource$Projects$Locations$Instances$Export, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
export(params: Params$Resource$Projects$Locations$Instances$Export, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
export(params: Params$Resource$Projects$Locations$Instances$Export, callback: BodyResponseCallback<Schema$Operation>): void;
export(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Gets details of a single Instance.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/looker.googleapis.com
* // - Login into gcloud by running:
* // ```sh
* // $ gcloud auth application-default login
* // ```
* // - Install the npm module by running:
* // ```sh
* // $ npm install googleapis
* // ```
*
* const {google} = require('googleapis');
* const looker = google.looker('v1');
*
* async function main() {
* const auth = new google.auth.GoogleAuth({
* // Scopes can be specified either as an array or as a single, space-delimited string.
* scopes: ['https://www.googl