import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace firebasedataconnect_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;
}
/**
* Firebase Data Connect API
*
* Firebase Data Connect is a relational database service for mobile and web apps that lets you build and scale using a fully-managed PostgreSQL database powered by Cloud SQL. The REST API lets developers manage the connections to their database, change the schema of their database, and query the database.
*
* @example
* ```js
* const {google} = require('googleapis');
* const firebasedataconnect = google.firebasedataconnect('v1');
* ```
*/
export class Firebasedataconnect {
context: APIRequestContext;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* The request message for Operations.CancelOperation.
*/
export interface Schema$CancelOperationRequest {
}
/**
* Settings for CloudSQL instance configuration.
*/
export interface Schema$CloudSqlInstance {
/**
* Required. Name of the CloudSQL instance, in the format: ``` projects/{project\}/locations/{location\}/instances/{instance\} ```
*/
instance?: string | null;
}
/**
* Connector consists of a set of operations, i.e. queries and mutations.
*/
export interface Schema$Connector {
/**
* Optional. Stores small amounts of arbitrary data.
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. [Output only] Create time stamp.
*/
createTime?: string | null;
/**
* Optional. Mutable human-readable name. 63 character limit.
*/
displayName?: string | null;
/**
* Output only. This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding. [AIP-154](https://google.aip.dev/154)
*/
etag?: string | null;
/**
* Optional. Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The relative resource name of the connector, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string | null;
/**
* Output only. A field that if true, indicates that the system is working to compile and deploy the connector.
*/
reconciling?: boolean | null;
/**
* Required. The source files that comprise the connector.
*/
source?: Schema$Source;
/**
* Output only. System-assigned, unique identifier.
*/
uid?: string | null;
/**
* Output only. [Output only] Update time stamp.
*/
updateTime?: string | null;
}
/**
* A data source that backs Firebase Data Connect services.
*/
export interface Schema$Datasource {
/**
* PostgreSQL configurations.
*/
postgresql?: Schema$PostgreSql;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
*/
export interface Schema$Empty {
}
/**
* The ExecuteMutation request to Firebase Data Connect.
*/
export interface Schema$ExecuteMutationRequest {
/**
* Required. The name of the GraphQL operation name. Required because all Connector operations must be named. See https://graphql.org/learn/queries/#operation-name.
*/
operationName?: string | null;
/**
* Optional. Values for GraphQL variables provided in this request.
*/
variables?: {
[key: string]: any;
} | null;
}
/**
* The ExecuteMutation response from Firebase Data Connect.
*/
export interface Schema$ExecuteMutationResponse {
/**
* The result of executing the requested operation.
*/
data?: {
[key: string]: any;
} | null;
/**
* Errors of this response.
*/
errors?: Schema$GraphqlError[];
}
/**
* The ExecuteQuery request to Firebase Data Connect.
*/
export interface Schema$ExecuteQueryRequest {
/**
* Required. The name of the GraphQL operation name. Required because all Connector operations must be named. See https://graphql.org/learn/queries/#operation-name.
*/
operationName?: string | null;
/**
* Optional. Values for GraphQL variables provided in this request.
*/
variables?: {
[key: string]: any;
} | null;
}
/**
* The ExecuteQuery response from Firebase Data Connect.
*/
export interface Schema$ExecuteQueryResponse {
/**
* The result of executing the requested operation.
*/
data?: {
[key: string]: any;
} | null;
/**
* Errors of this response.
*/
errors?: Schema$GraphqlError[];
}
/**
* Individual files.
*/
export interface Schema$File {
/**
* Required. The file's textual content.
*/
content?: string | null;
/**
* Required. The file name including folder path, if applicable. The path should be relative to a local workspace (e.g. dataconnect/(schema|connector)/x.gql) and not an absolute path (e.g. /absolute/path/(schema|connector)/x.gql).
*/
path?: string | null;
}
/**
* GraphqlError conforms to the GraphQL error spec. https://spec.graphql.org/draft/#sec-Errors Firebase Data Connect API surfaces `GraphqlError` in various APIs: - Upon compile error, `UpdateSchema` and `UpdateConnector` return Code.Invalid_Argument with a list of `GraphqlError` in error details. - Upon query compile error, `ExecuteGraphql` and `ExecuteGraphqlRead` return Code.OK with a list of `GraphqlError` in response body. - Upon query execution error, `ExecuteGraphql`, `ExecuteGraphqlRead`, `ExecuteMutation` and `ExecuteQuery` all return Code.OK with a list of `GraphqlError` in response body.
*/
export interface Schema$GraphqlError {
/**
* Additional error information.
*/
extensions?: Schema$GraphqlErrorExtensions;
/**
* The source locations where the error occurred. Locations should help developers and toolings identify the source of error quickly. Included in admin endpoints (`ExecuteGraphql`, `ExecuteGraphqlRead`, `UpdateSchema` and `UpdateConnector`) to reference the provided GraphQL GQL document. Omitted in `ExecuteMutation` and `ExecuteQuery` since the caller shouldn't have access access the underlying GQL source.
*/
locations?: Schema$SourceLocation[];
/**
* The detailed error message. The message should help developer understand the underlying problem without leaking internal data.
*/
message?: string | null;
/**
* The result field which could not be populated due to error. Clients can use path to identify whether a null result is intentional or caused by a runtime error. It should be a list of string or index from the root of GraphQL query document.
*/
path?: any[] | null;
}
/**
* GraphqlErrorExtensions contains additional information of `GraphqlError`.
*/
export interface Schema$GraphqlErrorExtensions {
/**
* Maps to canonical gRPC codes. If not specified, it represents `Code.INTERNAL`.
*/
code?: string | null;
/**
* More detailed error message to assist debugging. It contains application business logic that are inappropriate to leak publicly. In the emulator, Data Connect API always includes it to assist local development and debugging. In the backend, ConnectorService always hides it. GraphqlService without impersonation always include it. GraphqlService with impersonation includes it only if explicitly opted-in with `include_debug_details` in `GraphqlRequestExtensions`.
*/
debugDetails?: string | null;
/**
* The source file name where the error occurred. Included only for `UpdateSchema` and `UpdateConnector`, it corresponds to `File.path` of the provided `Source`.
*/
file?: string | null;
/**
* Distinguish which schema or connector the error originates from. It should be set on errors from control plane APIs (e.g. `UpdateSchema`, `UpdateConnector`).
*/
resource?: string | null;
}
/**
* The GraphQL request to Firebase Data Connect. It strives to match the GraphQL over HTTP spec. https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#post
*/
export interface Schema$GraphqlRequest {
/**
* Optional. Additional GraphQL request information.
*/
extensions?: Schema$GraphqlRequestExtensions;
/**
* Optional. The name of the GraphQL operation name. Required only if `query` contains multiple operations. See https://graphql.org/learn/queries/#operation-name.
*/
operationName?: string | null;
/**
* Required. The GraphQL query document source.
*/
query?: string | null;
/**
* Optional. Values for GraphQL variables provided in this request.
*/
variables?: {
[key: string]: any;
} | null;
}
/**
* GraphqlRequestExtensions contains additional information of `GraphqlRequest`.
*/
export interface Schema$GraphqlRequestExtensions {
/**
* Optional. If set, impersonate a request with given Firebase Auth context and evaluate the auth policies on the operation. If omitted, bypass any defined auth policies.
*/
impersonate?: Schema$Impersonation;
}
/**
* The GraphQL response from Firebase Data Connect. It strives to match the GraphQL over HTTP spec. Note: Firebase Data Connect always responds with `Content-Type: application/json`. https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#body
*/
export interface Schema$GraphqlResponse {
/**
* The result of the execution of the requested operation. If an error was raised before execution begins, the data entry should not be present in the result. (a request error: https://spec.graphql.org/draft/#sec-Errors.Request-Errors) If an error was raised during the execution that prevented a valid response, the data entry in the response should be null. (a field error: https://spec.graphql.org/draft/#sec-Errors.Error-Result-Format)
*/
data?: {
[key: string]: any;
} | null;
/**
* Errors of this response. If the data entry in the response is not present, the errors entry must be present. It conforms to https://spec.graphql.org/draft/#sec-Errors.
*/
errors?: Schema$GraphqlError[];
}
/**
* The Impersonate request to Firebase Data Connect.
*/
export interface Schema$ImpersonateRequest {
/**
* Optional. Additional GraphQL request information.
*/
extensions?: Schema$GraphqlRequestExtensions;
/**
* Required. The name of the GraphQL operation name. Required because all Connector operations must be named. See https://graphql.org/learn/queries/#operation-name.
*/
operationName?: string | null;
/**
* Optional. Values for GraphQL variables provided in this request.
*/
variables?: {
[key: string]: any;
} | null;
}
/**
* Impersonation configures the Firebase Auth context to impersonate.
*/
export interface Schema$Impersonation {
/**
* Evaluate the auth policy with a customized JWT auth token. Should follow the Firebase Auth token format. https://firebase.google.com/docs/rules/rules-and-auth For example: a verified user may have auth_claims of {"sub": , "email_verified": true\}
*/
authClaims?: {
[key: string]: any;
} | null;
/**
* Optional. If set, include debug details in GraphQL error extensions.
*/
includeDebugDetails?: boolean | null;
/**
* Evaluate the auth policy as an unauthenticated request. Can only be set to true.
*/
unauthenticated?: boolean | null;
}
/**
* Message for response to listing Connectors. By default, `connectors.source` will not be included in the response. To specify the fields included in the response, the response field mask can be provided by using the query parameter `$fields` or the header `X-Goog-FieldMask`.
*/
export interface Schema$ListConnectorsResponse {
/**
* The list of Connectors.
*/
connectors?: Schema$Connector[];
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* The response message for Locations.ListLocations.
*/
export interface Schema$ListLocationsResponse {
/**
* A list of locations that matches the specified filter in the request.
*/
locations?: Schema$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[];
}
/**
* Message for response to listing Schemas. By default, `schemas.source` will not be included in the response. To specify the fields included in the response, the response field mask can be provided by using the query parameter `$fields` or the header `X-Goog-FieldMask`.
*/
export interface Schema$ListSchemasResponse {
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
/**
* The list of Schemas.
*/
schemas?: Schema$Schema[];
/**
* Locations that could not be reached.
*/
unreachable?: string[] | null;
}
/**
* Message for response to listing Services.
*/
export interface Schema$ListServicesResponse {
/**
* A token, which can be sent as `page_token` to retrieve the next page. If this field is omitted, there are no subsequent pages.
*/
nextPageToken?: string | null;
/**
* The list of Services.
*/
services?: Schema$Service[];
/**
* Locations that could not be reached.
*/
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;
}
/**
* 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. Note: This message is auto-generated by CCFE. CCFE's storage, called Resource Metadata Store (RMS), holds metadata about long-running operations (i.e. OperationMetadata) and resources (i.e. ResourceMetadata). OperationMetadata documents the status of the operation. See [CCFE documentation for sidechannel data](https://g3doc.corp.google.com/cloud/control2/g3doc/dev/codelab_extras/sidechannel.md?cl=head#sidechannel-data) and yaqs/4289526912465764352.
*/
export interface Schema$OperationMetadata {
/**
* Output only. API version used to start the operation.
*/
apiVersion?: string | null;
/**
* Output only. The time the operation was created.
*/
createTime?: string | null;
/**
* Output only. The time the operation finished running.
*/
endTime?: string | null;
/**
* Output only. Identifies whether the user has requested cancellation of the operation. Operations that have been cancelled successfully have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
*/
requestedCancellation?: boolean | null;
/**
* Output only. Human-readable status of the operation, if any.
*/
statusMessage?: string | null;
/**
* Output only. Server-defined resource path for the target of the operation.
*/
target?: string | null;
/**
* Output only. Name of the verb executed by the operation.
*/
verb?: string | null;
}
/**
* Settings for PostgreSQL data source.
*/
export interface Schema$PostgreSql {
/**
* Cloud SQL configurations.
*/
cloudSql?: Schema$CloudSqlInstance;
/**
* Required. Name of the PostgreSQL database.
*/
database?: string | null;
/**
* Output only. Ephemeral is true if this data connect service is served from temporary in-memory emulation of Postgres. While Cloud SQL is being provisioned, the data connect service provides the ephemeral service to help developers get started. Once the Cloud SQL is provisioned, Data Connect service will transfer its data on a best-effort basis to the Cloud SQL instance. WARNING: Ephemeral data sources will expire after 24 hour. The data will be lost if they aren't transferred to the Cloud SQL instance. WARNING: When `ephemeral=true`, mutations to the database are not guaranteed to be durably persisted, even if an OK status code is returned. All or parts of the data may be lost or reverted to earlier versions.
*/
ephemeral?: boolean | null;
/**
* Optional. Configure how to perform Postgresql schema migration.
*/
schemaMigration?: string | null;
/**
* Optional. Configure how much Postgresql schema validation to perform.
*/
schemaValidation?: string | null;
/**
* No Postgres data source is linked. If set, don't allow `database` and `schema_validation` to be configured.
*/
unlinked?: boolean | null;
}
/**
* The application schema of a Firebase Data Connect service.
*/
export interface Schema$Schema {
/**
* Optional. Stores small amounts of arbitrary data.
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. [Output only] Create time stamp.
*/
createTime?: string | null;
/**
* Required. The data sources linked in the schema.
*/
datasources?: Schema$Datasource[];
/**
* Optional. Mutable human-readable name. 63 character limit.
*/
displayName?: string | null;
/**
* Output only. This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding. [AIP-154](https://google.aip.dev/154)
*/
etag?: string | null;
/**
* Optional. Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The relative resource name of the schema, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ``` Right now, the only supported schema is "main".
*/
name?: string | null;
/**
* Output only. A field that if true, indicates that the system is working to compile and deploy the schema.
*/
reconciling?: boolean | null;
/**
* Required. The source files that comprise the application schema.
*/
source?: Schema$Source;
/**
* Output only. System-assigned, unique identifier.
*/
uid?: string | null;
/**
* Output only. [Output only] Update time stamp.
*/
updateTime?: string | null;
}
/**
* A Firebase Data Connect service.
*/
export interface Schema$Service {
/**
* Optional. Stores small amounts of arbitrary data.
*/
annotations?: {
[key: string]: string;
} | null;
/**
* Output only. [Output only] Create time stamp.
*/
createTime?: string | null;
/**
* Optional. Mutable human-readable name. 63 character limit.
*/
displayName?: string | null;
/**
* Output only. This checksum is computed by the server based on the value of other fields, and may be sent on update and delete requests to ensure the client has an up-to-date value before proceeding. [AIP-154](https://google.aip.dev/154)
*/
etag?: string | null;
/**
* Optional. Labels as key value pairs.
*/
labels?: {
[key: string]: string;
} | null;
/**
* Identifier. The relative resource name of the Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ``` Note that the service ID is specific to Firebase Data Connect and does not correspond to any of the instance IDs of the underlying data source connections.
*/
name?: string | null;
/**
* Output only. A field that if true, indicates that the system is working update the service.
*/
reconciling?: boolean | null;
/**
* Output only. System-assigned, unique identifier.
*/
uid?: string | null;
/**
* Output only. [Output only] Update time stamp.
*/
updateTime?: string | null;
}
/**
* Used to represent a set of source files.
*/
export interface Schema$Source {
/**
* Required. The files that comprise the source set.
*/
files?: Schema$File[];
}
/**
* SourceLocation references a location in a GraphQL source.
*/
export interface Schema$SourceLocation {
/**
* Column number starting at 1.
*/
column?: number | null;
/**
* Line number starting at 1.
*/
line?: number | 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;
}
export class Resource$Projects {
context: APIRequestContext;
locations: Resource$Projects$Locations;
constructor(context: APIRequestContext);
}
export class Resource$Projects$Locations {
context: APIRequestContext;
operations: Resource$Projects$Locations$Operations;
services: Resource$Projects$Locations$Services;
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/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.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/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.list({
* // Optional. Unless explicitly documented otherwise, don't use this unsupported field which is primarily intended 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. Unless explicitly documented otherwise, don't use this unsupported field which is primarily intended 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$Operations {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* 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`.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.operations.cancel({
* // The name of the operation resource to be cancelled.
* name: 'projects/my-project/locations/my-location/operations/my-operation',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {}
* },
* });
* console.log(res.data);
*
* // Example 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.
*/
cancel(params: Params$Resource$Projects$Locations$Operations$Cancel, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
cancel(params?: Params$Resource$Projects$Locations$Operations$Cancel, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
cancel(params: Params$Resource$Projects$Locations$Operations$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
cancel(params: Params$Resource$Projects$Locations$Operations$Cancel, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
cancel(params: Params$Resource$Projects$Locations$Operations$Cancel, callback: BodyResponseCallback<Schema$Empty>): void;
cancel(callback: BodyResponseCallback<Schema$Empty>): void;
/**
* 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`.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.operations.delete({
* // The name of the operation resource to be deleted.
* name: 'projects/my-project/locations/my-location/operations/my-operation',
* });
* console.log(res.data);
*
* // Example 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$Operations$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
delete(params?: Params$Resource$Projects$Locations$Operations$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
delete(params: Params$Resource$Projects$Locations$Operations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
delete(params: Params$Resource$Projects$Locations$Operations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
delete(params: Params$Resource$Projects$Locations$Operations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
delete(callback: BodyResponseCallback<Schema$Empty>): void;
/**
* 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.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.operations.get({
* // The name of the operation resource.
* name: 'projects/my-project/locations/my-location/operations/my-operation',
* });
* 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.
*/
get(params: Params$Resource$Projects$Locations$Operations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
get(params?: Params$Resource$Projects$Locations$Operations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
get(params: Params$Resource$Projects$Locations$Operations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
get(params: Params$Resource$Projects$Locations$Operations$Get, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
get(params: Params$Resource$Projects$Locations$Operations$Get, callback: BodyResponseCallback<Schema$Operation>): void;
get(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.operations.list({
* // The standard list filter.
* filter: 'placeholder-value',
* // The name of the operation's parent resource.
* name: 'projects/my-project/locations/my-location',
* // The standard list page size.
* pageSize: 'placeholder-value',
* // The standard list page token.
* pageToken: 'placeholder-value',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "nextPageToken": "my_nextPageToken",
* // "operations": []
* // }
* }
*
* 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$Operations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
list(params?: Params$Resource$Projects$Locations$Operations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListOperationsResponse>>;
list(params: Params$Resource$Projects$Locations$Operations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
list(params: Params$Resource$Projects$Locations$Operations$List, options: MethodOptions | BodyResponseCallback<Schema$ListOperationsResponse>, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
list(params: Params$Resource$Projects$Locations$Operations$List, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
list(callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
}
export interface Params$Resource$Projects$Locations$Operations$Cancel extends StandardParameters {
/**
* The name of the operation resource to be cancelled.
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$CancelOperationRequest;
}
export interface Params$Resource$Projects$Locations$Operations$Delete extends StandardParameters {
/**
* The name of the operation resource to be deleted.
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$Operations$Get extends StandardParameters {
/**
* The name of the operation resource.
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$Operations$List extends StandardParameters {
/**
* The standard list filter.
*/
filter?: string;
/**
* The name of the operation's parent resource.
*/
name?: string;
/**
* The standard list page size.
*/
pageSize?: number;
/**
* The standard list page token.
*/
pageToken?: string;
}
export class Resource$Projects$Locations$Services {
context: APIRequestContext;
connectors: Resource$Projects$Locations$Services$Connectors;
schemas: Resource$Projects$Locations$Services$Schemas;
constructor(context: APIRequestContext);
/**
* Creates a new Service in a given project and location.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.create({
* // Required. Value of parent.
* parent: 'projects/my-project/locations/my-location',
* // Optional. 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: 'placeholder-value',
* // Required. The ID to use for the service, which will become the final component of the service's resource name.
* serviceId: 'placeholder-value',
* // Optional. If set, validate the request and preview the Service, but do not actually create it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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$Services$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
create(params?: Params$Resource$Projects$Locations$Services$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
create(params: Params$Resource$Projects$Locations$Services$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
create(params: Params$Resource$Projects$Locations$Services$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
create(params: Params$Resource$Projects$Locations$Services$Create, callback: BodyResponseCallback<Schema$Operation>): void;
create(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Deletes a single Service.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.delete({
* // Optional. If true and the Service is not found, the request will succeed but no action will be taken on the server.
* allowMissing: 'placeholder-value',
* // Optional. The etag of the Service. If this is provided, it must match the server's etag.
* etag: 'placeholder-value',
* // Optional. If set to true, any child resources (i.e. Schema, SchemaRevisions, Connectors, and ConnectorRevisions) will also be deleted. Otherwise, the request will only work if the Service has no child resources.
* force: 'placeholder-value',
* // Required. The name of the service to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
* name: 'projects/my-project/locations/my-location/services/my-service',
* // Optional. 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 after 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: 'placeholder-value',
* // Optional. If set, validate the request and preview the Service, but do not actually delete it.
* validateOnly: 'placeholder-value',
* });
* 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$Services$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
delete(params?: Params$Resource$Projects$Locations$Services$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
delete(params: Params$Resource$Projects$Locations$Services$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
delete(params: Params$Resource$Projects$Locations$Services$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
delete(params: Params$Resource$Projects$Locations$Services$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
delete(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Execute any GraphQL query and mutation against the Firebase Data Connect's generated GraphQL schema. Grants full read and write access to the connected data sources. Note: Use introspection query to explore the generated GraphQL schema.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.executeGraphql({
* // Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
* name: 'projects/my-project/locations/my-location/services/my-service',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "extensions": {},
* // "operationName": "my_operationName",
* // "query": "my_query",
* // "variables": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
executeGraphql(params: Params$Resource$Projects$Locations$Services$Executegraphql, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
executeGraphql(params?: Params$Resource$Projects$Locations$Services$Executegraphql, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GraphqlResponse>>;
executeGraphql(params: Params$Resource$Projects$Locations$Services$Executegraphql, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
executeGraphql(params: Params$Resource$Projects$Locations$Services$Executegraphql, options: MethodOptions | BodyResponseCallback<Schema$GraphqlResponse>, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
executeGraphql(params: Params$Resource$Projects$Locations$Services$Executegraphql, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
executeGraphql(callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
/**
* Execute any GraphQL query against the Firebase Data Connect's generated GraphQL schema. Grants full read to the connected data sources. `ExecuteGraphqlRead` is identical to `ExecuteGraphql` except it only accepts read-only query.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.executeGraphqlRead({
* // Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
* name: 'projects/my-project/locations/my-location/services/my-service',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "extensions": {},
* // "operationName": "my_operationName",
* // "query": "my_query",
* // "variables": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
executeGraphqlRead(params: Params$Resource$Projects$Locations$Services$Executegraphqlread, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
executeGraphqlRead(params?: Params$Resource$Projects$Locations$Services$Executegraphqlread, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GraphqlResponse>>;
executeGraphqlRead(params: Params$Resource$Projects$Locations$Services$Executegraphqlread, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
executeGraphqlRead(params: Params$Resource$Projects$Locations$Services$Executegraphqlread, options: MethodOptions | BodyResponseCallback<Schema$GraphqlResponse>, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
executeGraphqlRead(params: Params$Resource$Projects$Locations$Services$Executegraphqlread, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
executeGraphqlRead(callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
/**
* Gets details of a single Service.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.get({
* // Required. The name of the service to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
* name: 'projects/my-project/locations/my-location/services/my-service',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* }
*
* 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$Services$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
get(params?: Params$Resource$Projects$Locations$Services$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Service>>;
get(params: Params$Resource$Projects$Locations$Services$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
get(params: Params$Resource$Projects$Locations$Services$Get, options: MethodOptions | BodyResponseCallback<Schema$Service>, callback: BodyResponseCallback<Schema$Service>): void;
get(params: Params$Resource$Projects$Locations$Services$Get, callback: BodyResponseCallback<Schema$Service>): void;
get(callback: BodyResponseCallback<Schema$Service>): void;
/**
* Execute introspection query against the Firebase Data Connect's generated GraphQL schema. GraphQL introspection query provides metadata such as what tables the schema have, what queries and mutations can be performed on the schema, and so on. Read more at https://graphql.org/learn/introspection. IntrospectGraphql can read schema metadata but cannot read rows from Cloud SQL instance, which can be done via ExecuteGraphqlRead.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.introspectGraphql({
* // Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
* name: 'projects/my-project/locations/my-location/services/my-service',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "extensions": {},
* // "operationName": "my_operationName",
* // "query": "my_query",
* // "variables": {}
* // }
* },
* });
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
introspectGraphql(params: Params$Resource$Projects$Locations$Services$Introspectgraphql, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
introspectGraphql(params?: Params$Resource$Projects$Locations$Services$Introspectgraphql, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GraphqlResponse>>;
introspectGraphql(params: Params$Resource$Projects$Locations$Services$Introspectgraphql, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
introspectGraphql(params: Params$Resource$Projects$Locations$Services$Introspectgraphql, options: MethodOptions | BodyResponseCallback<Schema$GraphqlResponse>, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
introspectGraphql(params: Params$Resource$Projects$Locations$Services$Introspectgraphql, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
introspectGraphql(callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
/**
* Lists Services in a given project and location.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.list({
* // Optional. Filtering results.
* filter: 'placeholder-value',
* // Optional. Hint for how to order the results.
* orderBy: 'placeholder-value',
* // Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
* pageSize: 'placeholder-value',
* // Optional. A page token, received from a previous `ListServices` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListServices` must match the call that provided the page token.
* pageToken: 'placeholder-value',
* // Required. Value of parent.
* parent: 'projects/my-project/locations/my-location',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "nextPageToken": "my_nextPageToken",
* // "services": [],
* // "unreachable": []
* // }
* }
*
* 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$Services$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
list(params?: Params$Resource$Projects$Locations$Services$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListServicesResponse>>;
list(params: Params$Resource$Projects$Locations$Services$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
list(params: Params$Resource$Projects$Locations$Services$List, options: MethodOptions | BodyResponseCallback<Schema$ListServicesResponse>, callback: BodyResponseCallback<Schema$ListServicesResponse>): void;
list(params: Params$Resource$Projects$Locations$Services$List, callback: BodyResponseCallback<Schema$ListServicesResponse>): void;
list(callback: BodyResponseCallback<Schema$ListServicesResponse>): void;
/**
* Updates the parameters of a single Service.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.patch({
* // Optional. If true and the Service is not found, a new Service will be created. In this case, `update_mask` is ignored.
* allowMissing: 'placeholder-value',
* // Identifier. The relative resource name of the Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ``` Note that the service ID is specific to Firebase Data Connect and does not correspond to any of the instance IDs of the underlying data source connections.
* name: 'projects/my-project/locations/my-location/services/my-service',
* // Optional. 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: 'placeholder-value',
* // Optional. Field mask is used to specify the fields to be overwritten in the Service 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 will be overwritten.
* updateMask: 'placeholder-value',
* // Optional. If set, validate the request and preview the Service, but do not actually update it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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.
*/
patch(params: Params$Resource$Projects$Locations$Services$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
patch(params?: Params$Resource$Projects$Locations$Services$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
patch(params: Params$Resource$Projects$Locations$Services$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
patch(params: Params$Resource$Projects$Locations$Services$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
patch(params: Params$Resource$Projects$Locations$Services$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
patch(callback: BodyResponseCallback<Schema$Operation>): void;
}
export interface Params$Resource$Projects$Locations$Services$Create extends StandardParameters {
/**
* Required. Value of parent.
*/
parent?: string;
/**
* Optional. 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 to use for the service, which will become the final component of the service's resource name.
*/
serviceId?: string;
/**
* Optional. If set, validate the request and preview the Service, but do not actually create it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Service;
}
export interface Params$Resource$Projects$Locations$Services$Delete extends StandardParameters {
/**
* Optional. If true and the Service is not found, the request will succeed but no action will be taken on the server.
*/
allowMissing?: boolean;
/**
* Optional. The etag of the Service. If this is provided, it must match the server's etag.
*/
etag?: string;
/**
* Optional. If set to true, any child resources (i.e. Schema, SchemaRevisions, Connectors, and ConnectorRevisions) will also be deleted. Otherwise, the request will only work if the Service has no child resources.
*/
force?: boolean;
/**
* Required. The name of the service to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
*/
name?: string;
/**
* Optional. 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 after 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;
/**
* Optional. If set, validate the request and preview the Service, but do not actually delete it.
*/
validateOnly?: boolean;
}
export interface Params$Resource$Projects$Locations$Services$Executegraphql extends StandardParameters {
/**
* Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$GraphqlRequest;
}
export interface Params$Resource$Projects$Locations$Services$Executegraphqlread extends StandardParameters {
/**
* Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$GraphqlRequest;
}
export interface Params$Resource$Projects$Locations$Services$Get extends StandardParameters {
/**
* Required. The name of the service to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$Services$Introspectgraphql extends StandardParameters {
/**
* Required. The relative resource name of Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$GraphqlRequest;
}
export interface Params$Resource$Projects$Locations$Services$List extends StandardParameters {
/**
* Optional. Filtering results.
*/
filter?: string;
/**
* Optional. Hint for how to order the results.
*/
orderBy?: string;
/**
* Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
*/
pageSize?: number;
/**
* Optional. A page token, received from a previous `ListServices` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListServices` must match the call that provided the page token.
*/
pageToken?: string;
/**
* Required. Value of parent.
*/
parent?: string;
}
export interface Params$Resource$Projects$Locations$Services$Patch extends StandardParameters {
/**
* Optional. If true and the Service is not found, a new Service will be created. In this case, `update_mask` is ignored.
*/
allowMissing?: boolean;
/**
* Identifier. The relative resource name of the Firebase Data Connect service, in the format: ``` projects/{project\}/locations/{location\}/services/{service\} ``` Note that the service ID is specific to Firebase Data Connect and does not correspond to any of the instance IDs of the underlying data source connections.
*/
name?: string;
/**
* Optional. 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;
/**
* Optional. Field mask is used to specify the fields to be overwritten in the Service 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 will be overwritten.
*/
updateMask?: string;
/**
* Optional. If set, validate the request and preview the Service, but do not actually update it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Service;
}
export class Resource$Projects$Locations$Services$Connectors {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* Creates a new Connector in a given project and location. The operations are validated against and must be compatible with the active schema. If the operations and schema are not compatible or if the schema is not present, this will result in an error.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.create({
* // Required. The ID to use for the connector, which will become the final component of the connector's resource name.
* connectorId: 'placeholder-value',
* // Required. Value for parent.
* parent: 'projects/my-project/locations/my-location/services/my-service',
* // Optional. 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: 'placeholder-value',
* // Optional. If set, validate the request and preview the Connector, but do not actually create it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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$Services$Connectors$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
create(params?: Params$Resource$Projects$Locations$Services$Connectors$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
create(params: Params$Resource$Projects$Locations$Services$Connectors$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
create(params: Params$Resource$Projects$Locations$Services$Connectors$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
create(params: Params$Resource$Projects$Locations$Services$Connectors$Create, callback: BodyResponseCallback<Schema$Operation>): void;
create(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Deletes a single Connector.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.delete({
* // Optional. If true and the Connector is not found, the request will succeed but no action will be taken on the server.
* allowMissing: 'placeholder-value',
* // Optional. The etag of the Connector. If this is provided, it must match the server's etag.
* etag: 'placeholder-value',
* // Optional. If set to true, any child resources (i.e. ConnectorRevisions) will also be deleted. Otherwise, the request will only work if the Connector has no child resources.
* force: 'placeholder-value',
* // Required. The name of the connector to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
* // Optional. 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 after 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: 'placeholder-value',
* // Optional. If set, validate the request and preview the Connector, but do not actually delete it.
* validateOnly: 'placeholder-value',
* });
* 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$Services$Connectors$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
delete(params?: Params$Resource$Projects$Locations$Services$Connectors$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
delete(params: Params$Resource$Projects$Locations$Services$Connectors$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
delete(params: Params$Resource$Projects$Locations$Services$Connectors$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
delete(params: Params$Resource$Projects$Locations$Services$Connectors$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
delete(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Execute a predefined mutation in a Connector.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.executeMutation(
* {
* // Required. The resource name of the connector to find the predefined mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "operationName": "my_operationName",
* // "variables": {}
* // }
* },
* },
* );
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
executeMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Executemutation, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
executeMutation(params?: Params$Resource$Projects$Locations$Services$Connectors$Executemutation, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ExecuteMutationResponse>>;
executeMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Executemutation, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
executeMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Executemutation, options: MethodOptions | BodyResponseCallback<Schema$ExecuteMutationResponse>, callback: BodyResponseCallback<Schema$ExecuteMutationResponse>): void;
executeMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Executemutation, callback: BodyResponseCallback<Schema$ExecuteMutationResponse>): void;
executeMutation(callback: BodyResponseCallback<Schema$ExecuteMutationResponse>): void;
/**
* Execute a predefined query in a Connector.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.executeQuery(
* {
* // Required. The resource name of the connector to find the predefined query, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "operationName": "my_operationName",
* // "variables": {}
* // }
* },
* },
* );
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
executeQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Executequery, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
executeQuery(params?: Params$Resource$Projects$Locations$Services$Connectors$Executequery, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ExecuteQueryResponse>>;
executeQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Executequery, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
executeQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Executequery, options: MethodOptions | BodyResponseCallback<Schema$ExecuteQueryResponse>, callback: BodyResponseCallback<Schema$ExecuteQueryResponse>): void;
executeQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Executequery, callback: BodyResponseCallback<Schema$ExecuteQueryResponse>): void;
executeQuery(callback: BodyResponseCallback<Schema$ExecuteQueryResponse>): void;
/**
* Gets details of a single Connector.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.get({
* // Required. The name of the connector to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* }
*
* 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$Services$Connectors$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
get(params?: Params$Resource$Projects$Locations$Services$Connectors$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Connector>>;
get(params: Params$Resource$Projects$Locations$Services$Connectors$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
get(params: Params$Resource$Projects$Locations$Services$Connectors$Get, options: MethodOptions | BodyResponseCallback<Schema$Connector>, callback: BodyResponseCallback<Schema$Connector>): void;
get(params: Params$Resource$Projects$Locations$Services$Connectors$Get, callback: BodyResponseCallback<Schema$Connector>): void;
get(callback: BodyResponseCallback<Schema$Connector>): void;
/**
* Impersonate a mutation defined on a Firebase Data Connect connector. It grants the admin SDK access to mutations defined in the given connector. The caller can choose to impersonate a particular Firebase Auth user, or skip @auth completely.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.impersonateMutation(
* {
* // Required. The resource name of the connector to find the predefined query/mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "extensions": {},
* // "operationName": "my_operationName",
* // "variables": {}
* // }
* },
* },
* );
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
impersonateMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
impersonateMutation(params?: Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GraphqlResponse>>;
impersonateMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
impersonateMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation, options: MethodOptions | BodyResponseCallback<Schema$GraphqlResponse>, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
impersonateMutation(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
impersonateMutation(callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
/**
* Impersonate a query defined on a Firebase Data Connect connector. It grants the admin SDK access to queries defined in the given connector. The caller can choose to impersonate a particular Firebase Auth user, or skip @auth completely.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.impersonateQuery(
* {
* // Required. The resource name of the connector to find the predefined query/mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "extensions": {},
* // "operationName": "my_operationName",
* // "variables": {}
* // }
* },
* },
* );
* console.log(res.data);
*
* // Example response
* // {
* // "data": {},
* // "errors": []
* // }
* }
*
* 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.
*/
impersonateQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
impersonateQuery(params?: Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GraphqlResponse>>;
impersonateQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
impersonateQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery, options: MethodOptions | BodyResponseCallback<Schema$GraphqlResponse>, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
impersonateQuery(params: Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery, callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
impersonateQuery(callback: BodyResponseCallback<Schema$GraphqlResponse>): void;
/**
* Lists Connectors in a given project and location.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.list({
* // Optional. Filtering results.
* filter: 'placeholder-value',
* // Optional. Hint for how to order the results.
* orderBy: 'placeholder-value',
* // Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
* pageSize: 'placeholder-value',
* // Optional. A page token, received from a previous `ListConnectors` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListConnectors` must match the call that provided the page token.
* pageToken: 'placeholder-value',
* // Required. Value of parent.
* parent: 'projects/my-project/locations/my-location/services/my-service',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "connectors": [],
* // "nextPageToken": "my_nextPageToken",
* // "unreachable": []
* // }
* }
*
* 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$Services$Connectors$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
list(params?: Params$Resource$Projects$Locations$Services$Connectors$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListConnectorsResponse>>;
list(params: Params$Resource$Projects$Locations$Services$Connectors$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
list(params: Params$Resource$Projects$Locations$Services$Connectors$List, options: MethodOptions | BodyResponseCallback<Schema$ListConnectorsResponse>, callback: BodyResponseCallback<Schema$ListConnectorsResponse>): void;
list(params: Params$Resource$Projects$Locations$Services$Connectors$List, callback: BodyResponseCallback<Schema$ListConnectorsResponse>): void;
list(callback: BodyResponseCallback<Schema$ListConnectorsResponse>): void;
/**
* Updates the parameters of a single Connector, and creates a new ConnectorRevision with the updated Connector. The operations are validated against and must be compatible with the live schema. If the operations and schema are not compatible or if the schema is not present, this will result in an error.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.connectors.patch({
* // Optional. If true and the Connector is not found, a new Connector will be created. In this case, `update_mask` is ignored.
* allowMissing: 'placeholder-value',
* // Identifier. The relative resource name of the connector, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/connectors/my-connector',
* // Optional. 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: 'placeholder-value',
* // Optional. Field mask is used to specify the fields to be overwritten in the Connector 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 will be overwritten.
* updateMask: 'placeholder-value',
* // Optional. If set, validate the request and preview the Connector, but do not actually update it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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.
*/
patch(params: Params$Resource$Projects$Locations$Services$Connectors$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
patch(params?: Params$Resource$Projects$Locations$Services$Connectors$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
patch(params: Params$Resource$Projects$Locations$Services$Connectors$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
patch(params: Params$Resource$Projects$Locations$Services$Connectors$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
patch(params: Params$Resource$Projects$Locations$Services$Connectors$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
patch(callback: BodyResponseCallback<Schema$Operation>): void;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Create extends StandardParameters {
/**
* Required. The ID to use for the connector, which will become the final component of the connector's resource name.
*/
connectorId?: string;
/**
* Required. Value for parent.
*/
parent?: string;
/**
* Optional. 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;
/**
* Optional. If set, validate the request and preview the Connector, but do not actually create it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Connector;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Delete extends StandardParameters {
/**
* Optional. If true and the Connector is not found, the request will succeed but no action will be taken on the server.
*/
allowMissing?: boolean;
/**
* Optional. The etag of the Connector. If this is provided, it must match the server's etag.
*/
etag?: string;
/**
* Optional. If set to true, any child resources (i.e. ConnectorRevisions) will also be deleted. Otherwise, the request will only work if the Connector has no child resources.
*/
force?: boolean;
/**
* Required. The name of the connector to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Optional. 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 after 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;
/**
* Optional. If set, validate the request and preview the Connector, but do not actually delete it.
*/
validateOnly?: boolean;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Executemutation extends StandardParameters {
/**
* Required. The resource name of the connector to find the predefined mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ExecuteMutationRequest;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Executequery extends StandardParameters {
/**
* Required. The resource name of the connector to find the predefined query, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ExecuteQueryRequest;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Get extends StandardParameters {
/**
* Required. The name of the connector to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Impersonatemutation extends StandardParameters {
/**
* Required. The resource name of the connector to find the predefined query/mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ImpersonateRequest;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Impersonatequery extends StandardParameters {
/**
* Required. The resource name of the connector to find the predefined query/mutation, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Request body metadata
*/
requestBody?: Schema$ImpersonateRequest;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$List extends StandardParameters {
/**
* Optional. Filtering results.
*/
filter?: string;
/**
* Optional. Hint for how to order the results.
*/
orderBy?: string;
/**
* Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
*/
pageSize?: number;
/**
* Optional. A page token, received from a previous `ListConnectors` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListConnectors` must match the call that provided the page token.
*/
pageToken?: string;
/**
* Required. Value of parent.
*/
parent?: string;
}
export interface Params$Resource$Projects$Locations$Services$Connectors$Patch extends StandardParameters {
/**
* Optional. If true and the Connector is not found, a new Connector will be created. In this case, `update_mask` is ignored.
*/
allowMissing?: boolean;
/**
* Identifier. The relative resource name of the connector, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/connectors/{connector\} ```
*/
name?: string;
/**
* Optional. 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;
/**
* Optional. Field mask is used to specify the fields to be overwritten in the Connector 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 will be overwritten.
*/
updateMask?: string;
/**
* Optional. If set, validate the request and preview the Connector, but do not actually update it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Connector;
}
export class Resource$Projects$Locations$Services$Schemas {
context: APIRequestContext;
constructor(context: APIRequestContext);
/**
* Creates a new Schema in a given project and location. Only creation of `schemas/main` is supported and calling create with any other schema ID will result in an error.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.schemas.create({
* // Required. Value for parent.
* parent: 'projects/my-project/locations/my-location/services/my-service',
* // Optional. 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: 'placeholder-value',
* // Required. The ID to use for the schema, which will become the final component of the schema's resource name. Currently, only `main` is supported and any other schema ID will result in an error.
* schemaId: 'placeholder-value',
* // Optional. If set, validate the request and preview the Schema, but do not actually update it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "datasources": [],
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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$Services$Schemas$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
create(params?: Params$Resource$Projects$Locations$Services$Schemas$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
create(params: Params$Resource$Projects$Locations$Services$Schemas$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
create(params: Params$Resource$Projects$Locations$Services$Schemas$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
create(params: Params$Resource$Projects$Locations$Services$Schemas$Create, callback: BodyResponseCallback<Schema$Operation>): void;
create(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Deletes a single Schema. Because the schema and connectors must be compatible at all times, if this is called while any connectors are active, this will result in an error.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.schemas.delete({
* // Optional. If true and the Schema is not found, the request will succeed but no action will be taken on the server.
* allowMissing: 'placeholder-value',
* // Optional. The etag of the Schema. If this is provided, it must match the server's etag.
* etag: 'placeholder-value',
* // Optional. If set to true, any child resources (i.e. SchemaRevisions) will also be deleted.
* force: 'placeholder-value',
* // Required. The name of the schema to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/schemas/my-schema',
* // Optional. 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 after 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: 'placeholder-value',
* // Optional. If set, validate the request and preview the Schema, but do not actually delete it.
* validateOnly: 'placeholder-value',
* });
* 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$Services$Schemas$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
delete(params?: Params$Resource$Projects$Locations$Services$Schemas$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
delete(params: Params$Resource$Projects$Locations$Services$Schemas$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
delete(params: Params$Resource$Projects$Locations$Services$Schemas$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
delete(params: Params$Resource$Projects$Locations$Services$Schemas$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
delete(callback: BodyResponseCallback<Schema$Operation>): void;
/**
* Gets details of a single Schema.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.schemas.get(
* {
* // Required. The name of the schema to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ```
* name: 'projects/my-project/locations/my-location/services/my-service/schemas/my-schema',
* },
* );
* console.log(res.data);
*
* // Example response
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "datasources": [],
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* }
*
* 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$Services$Schemas$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
get(params?: Params$Resource$Projects$Locations$Services$Schemas$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Schema>>;
get(params: Params$Resource$Projects$Locations$Services$Schemas$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
get(params: Params$Resource$Projects$Locations$Services$Schemas$Get, options: MethodOptions | BodyResponseCallback<Schema$Schema>, callback: BodyResponseCallback<Schema$Schema>): void;
get(params: Params$Resource$Projects$Locations$Services$Schemas$Get, callback: BodyResponseCallback<Schema$Schema>): void;
get(callback: BodyResponseCallback<Schema$Schema>): void;
/**
* Lists Schemas in a given project and location. Note that only `schemas/main` is supported, so this will always return at most one Schema.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.schemas.list({
* // Optional. Filtering results.
* filter: 'placeholder-value',
* // Optional. Hint for how to order the results.
* orderBy: 'placeholder-value',
* // Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
* pageSize: 'placeholder-value',
* // Optional. A page token, received from a previous `ListSchemas` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListSchemas` must match the call that provided the page token.
* pageToken: 'placeholder-value',
* // Required. Value of parent.
* parent: 'projects/my-project/locations/my-location/services/my-service',
* });
* console.log(res.data);
*
* // Example response
* // {
* // "nextPageToken": "my_nextPageToken",
* // "schemas": [],
* // "unreachable": []
* // }
* }
*
* 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$Services$Schemas$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
list(params?: Params$Resource$Projects$Locations$Services$Schemas$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListSchemasResponse>>;
list(params: Params$Resource$Projects$Locations$Services$Schemas$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
list(params: Params$Resource$Projects$Locations$Services$Schemas$List, options: MethodOptions | BodyResponseCallback<Schema$ListSchemasResponse>, callback: BodyResponseCallback<Schema$ListSchemasResponse>): void;
list(params: Params$Resource$Projects$Locations$Services$Schemas$List, callback: BodyResponseCallback<Schema$ListSchemasResponse>): void;
list(callback: BodyResponseCallback<Schema$ListSchemasResponse>): void;
/**
* Updates the parameters of a single Schema, and creates a new SchemaRevision with the updated Schema.
* @example
* ```js
* // Before running the sample:
* // - Enable the API at:
* // https://console.developers.google.com/apis/api/firebasedataconnect.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 firebasedataconnect = google.firebasedataconnect('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 firebasedataconnect.projects.locations.services.schemas.patch({
* // Optional. If true and the Schema is not found, a new Schema will be created. In this case, `update_mask` is ignored.
* allowMissing: 'placeholder-value',
* // Identifier. The relative resource name of the schema, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ``` Right now, the only supported schema is "main".
* name: 'projects/my-project/locations/my-location/services/my-service/schemas/my-schema',
* // Optional. 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: 'placeholder-value',
* // Optional. Field mask is used to specify the fields to be overwritten in the Schema 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 will be overwritten.
* updateMask: 'placeholder-value',
* // Optional. If set, validate the request and preview the Schema, but do not actually update it.
* validateOnly: 'placeholder-value',
*
* // Request body metadata
* requestBody: {
* // request body parameters
* // {
* // "annotations": {},
* // "createTime": "my_createTime",
* // "datasources": [],
* // "displayName": "my_displayName",
* // "etag": "my_etag",
* // "labels": {},
* // "name": "my_name",
* // "reconciling": false,
* // "source": {},
* // "uid": "my_uid",
* // "updateTime": "my_updateTime"
* // }
* },
* });
* 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.
*/
patch(params: Params$Resource$Projects$Locations$Services$Schemas$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
patch(params?: Params$Resource$Projects$Locations$Services$Schemas$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
patch(params: Params$Resource$Projects$Locations$Services$Schemas$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
patch(params: Params$Resource$Projects$Locations$Services$Schemas$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
patch(params: Params$Resource$Projects$Locations$Services$Schemas$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
patch(callback: BodyResponseCallback<Schema$Operation>): void;
}
export interface Params$Resource$Projects$Locations$Services$Schemas$Create extends StandardParameters {
/**
* Required. Value for parent.
*/
parent?: string;
/**
* Optional. 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 to use for the schema, which will become the final component of the schema's resource name. Currently, only `main` is supported and any other schema ID will result in an error.
*/
schemaId?: string;
/**
* Optional. If set, validate the request and preview the Schema, but do not actually update it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Schema;
}
export interface Params$Resource$Projects$Locations$Services$Schemas$Delete extends StandardParameters {
/**
* Optional. If true and the Schema is not found, the request will succeed but no action will be taken on the server.
*/
allowMissing?: boolean;
/**
* Optional. The etag of the Schema. If this is provided, it must match the server's etag.
*/
etag?: string;
/**
* Optional. If set to true, any child resources (i.e. SchemaRevisions) will also be deleted.
*/
force?: boolean;
/**
* Required. The name of the schema to delete, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ```
*/
name?: string;
/**
* Optional. 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 after 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;
/**
* Optional. If set, validate the request and preview the Schema, but do not actually delete it.
*/
validateOnly?: boolean;
}
export interface Params$Resource$Projects$Locations$Services$Schemas$Get extends StandardParameters {
/**
* Required. The name of the schema to retrieve, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ```
*/
name?: string;
}
export interface Params$Resource$Projects$Locations$Services$Schemas$List extends StandardParameters {
/**
* Optional. Filtering results.
*/
filter?: string;
/**
* Optional. Hint for how to order the results.
*/
orderBy?: string;
/**
* Optional. Requested page size. Server may return fewer items than requested. If unspecified, server will pick an appropriate default.
*/
pageSize?: number;
/**
* Optional. A page token, received from a previous `ListSchemas` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListSchemas` must match the call that provided the page token.
*/
pageToken?: string;
/**
* Required. Value of parent.
*/
parent?: string;
}
export interface Params$Resource$Projects$Locations$Services$Schemas$Patch extends StandardParameters {
/**
* Optional. If true and the Schema is not found, a new Schema will be created. In this case, `update_mask` is ignored.
*/
allowMissing?: boolean;
/**
* Identifier. The relative resource name of the schema, in the format: ``` projects/{project\}/locations/{location\}/services/{service\}/schemas/{schema\} ``` Right now, the only supported schema is "main".
*/
name?: string;
/**
* Optional. 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;
/**
* Optional. Field mask is used to specify the fields to be overwritten in the Schema 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 will be overwritten.
*/
updateMask?: string;
/**
* Optional. If set, validate the request and preview the Schema, but do not actually update it.
*/
validateOnly?: boolean;
/**
* Request body metadata
*/
requestBody?: Schema$Schema;
}
export {};
}
