@google-cloud/datastore/build/src/index.d.ts

/*!
 * Copyright 2018 Google LLC.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/// <reference types="node" />
import { ClientStub, ChannelCredentials, GoogleAuth, GoogleAuthOptions, CallOptions, Operation, ServiceError } from 'google-gax';
import { entity, Entities, Entity, ValueProto } from './entity';
import Key = entity.Key;
export { Entity, Key };
import { GetIndexesCallback, GetIndexesOptions, GetIndexesResponse, Index } from './index-class';
import { Query } from './query';
import { DatastoreRequest, CommitCallback, CommitResponse, SaveCallback, SaveResponse } from './request';
import { Transaction } from './transaction';
import { google } from '../protos/protos';
export declare type PathType = string | number | entity.Int;
export interface BooleanObject {
    [key: string]: boolean;
}
export interface EntityProtoReduceAccumulator {
    [key: string]: ValueProto;
}
export interface EntityProtoReduceData {
    value: ValueProto;
    excludeFromIndexes: ValueProto;
    name: string | number;
}
export declare type UpdateCallback = CommitCallback;
export declare type UpdateResponse = CommitResponse;
export declare type UpsertCallback = CommitCallback;
export declare type UpsertResponse = CommitResponse;
export declare type InsertCallback = CommitCallback;
export declare type InsertResponse = CommitResponse;
export interface LongRunningCallback {
    (err: ServiceError | null, operation?: Operation, apiResponse?: google.longrunning.IOperation): void;
}
export declare type LongRunningResponse = [Operation, google.longrunning.IOperation];
export interface ExportEntitiesConfig extends Omit<google.datastore.admin.v1.IExportEntitiesRequest, 'projectId'> {
    bucket?: string | {
        name: string;
    };
    kinds?: string[];
    namespaces?: string[];
    gaxOptions?: CallOptions;
}
export interface ImportEntitiesConfig extends Omit<google.datastore.admin.v1.IImportEntitiesRequest, 'projectId'> {
    file?: string | {
        bucket: {
            name: string;
        };
        name: string;
    };
    kinds?: string[];
    namespaces?: string[];
    gaxOptions?: CallOptions;
}
/**
 * Idiomatic class for interacting with Cloud Datastore. Uses the lower-level
 * {@link DatastoreClient} class under the hood.
 *
 * In addition to the constructor options shown here, the {@link Datastore}
 * class constructor accepts the same options accepted by
 * {@link DatastoreClient}.
 *
 * <h4>The Datastore Emulator</h4>
 *
 * Make sure you have the <a href="https://cloud.google.com/sdk/downloads">
 * gcloud SDK installed</a>, then run:
 *
 * <pre>
 *   $ gcloud beta emulators datastore start --no-legacy
 * </pre>
 *
 * You will see the following printed:
 *
 * <pre>
 *   [datastore] API endpoint: http://localhost:8005
 *   [datastore] If you are using a library that supports the
 *               DATASTORE_EMULATOR_HOST environment variable, run:
 *   [datastore]
 *   [datastore]   export DATASTORE_EMULATOR_HOST=localhost:8005
 *   [datastore]
 *   [datastore] Dev App Server is now running.
 * </pre>
 *
 * Set that environment variable and your localhost Datastore will
 * automatically be used. You can also pass this address in manually with
 * `apiEndpoint`.
 *
 * Additionally, `DATASTORE_PROJECT_ID` is recognized. If you have this set,
 * you don't need to provide a `projectId`.
 *
 *
 * See {@link https://cloud.google.com/datastore/docs/concepts/overview| Cloud Datastore Concepts Overview}
 *
 * @param {object} [options] Configuration options.
 * @param {string} [options.apiEndpoint] Override the default API endpoint used
 *     to reach Datastore. This is useful for connecting to your local Datastore
 *     server (usually "http://localhost:8080").
 * @param {string} [options.namespace] Namespace to isolate transactions to.
 *
 * @example Import the client library
 * ```
 * const {Datastore} = require('@google-cloud/datastore');
 *
 * ```
 * @example Create a client that uses <a href="https://cloud.google.com/docs/authentication/production#providing_credentials_to_your_application">Application Default Credentials (ADC)</a>:
 * ```
 * const datastore = new Datastore();
 *
 * ```
 * @example Create a client with <a href="https://cloud.google.com/docs/authentication/production#obtaining_and_providing_service_account_credentials_manually">explicit credentials</a>:
 * ```
 * const datastore = new Datastore({
 *   projectId: 'your-project-id',
 *   keyFilename: '/path/to/keyfile.json'
 * });
 *
 * ```
 * @example Retrieving Records
 * ```
 * const {Datastore} = require('@google-cloud/datastore');
 * const datastore = new Datastore();
 *
 * // Records, called "entities" in Datastore, are retrieved by using a key. The
 * // key is more than a numeric identifier, it is a complex data structure that
 * // can be used to model relationships. The simplest key has a string `kind`
 * // value, and either a numeric `id` value, or a string `name` value.
 * //
 * // A single record can be retrieved with {@link Datastore#key} and
 * // {@link Datastore#get}.
 * //-
 * const key = datastore.key(['Company', 'Google']);
 *
 * datastore.get(key, function(err, entity) {
 *   // entity = The record.
 *   // entity[datastore.KEY] = The key for this entity.
 * });
 *
 * //-
 * // <h3>Querying Records</h3>
 * //
 * // Create a query with {@link Datastore#createQuery}.
 * //-
 * const query = datastore.createQuery('Company');
 *
 * //-
 * // Multiple records can be found that match criteria with
 * // {@link Query#filter}.
 * //-
 * query.filter('location', 'CA');
 *
 * //-
 * // Records can also be ordered with {@link Query#order}.
 * //-
 * query.order('name');
 *
 * //-
 * // The number of records returned can be specified with
 * // {@link Query#limit}.
 * //-
 * query.limit(5);
 *
 * //-
 * // Records' key structures can also be queried with
 * // {@link Query#hasAncestor}.
 * //-
 * const ancestorKey = datastore.key(['ParentCompany', 'Alphabet']);
 *
 * query.hasAncestor(ancestorKey);
 *
 * //-
 * // Run the query with {@link Datastore#runQuery}.
 * //-
 * datastore.runQuery(query, (err, entities) => {
 *   // entities = An array of records.
 *
 *   // Access the Key object for an entity.
 *   const firstEntityKey = entities[0][datastore.KEY];
 * });
 *
 * ```
 * @example Paginating Records
 * ```
 * // Imagine building a website that allows a user to sift through hundreds of
 * // their contacts. You'll likely want to only display a subset of these at
 * // once, so you set a limit.
 * //-
 * const express = require('express');
 * const app = express();
 *
 * const NUM_RESULTS_PER_PAGE = 15;
 *
 * app.get('/contacts', (req, res) => {
 *   const query = datastore.createQuery('Contacts')
 *     .limit(NUM_RESULTS_PER_PAGE);
 *
 *   if (req.query.nextPageCursor) {
 *     query.start(req.query.nextPageCursor);
 *   }
 *
 *   datastore.runQuery(query, (err, entities, info) => {
 *     if (err) {
 *       // Error handling omitted.
 *       return;
 *     }
 *
 *     // Respond to the front end with the contacts and the cursoring token
 *     // from the query we just ran.
 *     const frontEndResponse = {
 *       contacts: entities
 *     };
 *
 *     // Check if  more results may exist.
 *     if (info.moreResults !== datastore.NO_MORE_RESULTS) {
 *       frontEndResponse.nextPageCursor = info.endCursor;
 *     }
 *
 *     res.render('contacts', frontEndResponse);
 *   });
 * });
 *
 * ```
 * @example Creating Records
 * ```
 * // New entities can be created and persisted with {@link Datastore#save}.
 * // The entitiy must have a key to be saved. If you don't specify an
 * // identifier for the key, one is generated for you.
 * //
 * // We will create a key with a `name` identifier, "Google".
 * //-
 * const key = datastore.key(['Company', 'Google']);
 *
 * const data = {
 *   name: 'Google',
 *   location: 'CA'
 * };
 *
 * datastore.save({
 *   key: key,
 *   data: data
 * }, (err) => {
 *   if (!err) {
 *     // Record saved successfully.
 *   }
 * });
 *
 * //-
 * // We can verify the data was saved by using {@link Datastore#get}.
 * //-
 * datastore.get(key, (err, entity) => {
 *   // entity = {
 *   //   name: 'Google',
 *   //   location: 'CA'
 *   // }
 * });
 *
 * //-
 * // If we want to update this record, we can modify the data object and re-
 * // save it.
 * //-
 * data.symbol = 'GOOG';
 *
 * datastore.save({
 *   key: key, // defined above (datastore.key(['Company', 'Google']))
 *   data: data
 * }, (err, entity) => {
 *   if (!err) {
 *     // Record updated successfully.
 *   }
 * });
 *
 * ```
 * @example Deleting Records
 * ```
 * // Entities can be removed from Datastore by passing the entity's key object
 * // to {@link Datastore#delete}.
 * //-
 * const key = datastore.key(['Company', 'Google']);
 *
 * datastore.delete(key, (err) => {
 *   if (!err) {
 *     // Record deleted successfully.
 *   }
 * });
 *
 * ```
 * @example Transactions
 * ```
 * // Complex logic can be wrapped in a transaction with
 * // {@link Datastore#transaction}. All queries and updates run within
 * // the transaction will be applied when the `done` function is called.
 * //-
 * const transaction = datastore.transaction();
 *
 * transaction.run((err) => {
 *   if (err) {
 *     // Error handling omitted.
 *   }
 *
 *   const key = datastore.key(['Company', 'Google']);
 *
 *   transaction.get(key, (err, entity) => {
 *     if (err) {
 *       // Error handling omitted.
 *     }
 *
 *     entity.symbol = 'GOOG';
 *
 *     transaction.save(entity);
 *
 *     transaction.commit((err) => {
 *       if (!err) {
 *         // Transaction committed successfully.
 *       }
 *     });
 *   });
 * });
 *
 * ```
 * @example Queries with Ancestors
 * ```
 * const {Datastore} = require('@google-cloud/datastore');
 * const datastore = new Datastore();
 *
 * const customerId1 = 2993844;
 * const customerId2 = 4993882;
 * const customerKey1 = datastore.key(['Customer', customerId1]);
 * const customerKey2 = datastore.key(['Customer', customerId2]);
 * const cookieKey1 = datastore.key(['Customer', customerId1, 'Cookie',
 * 'cookie28839']); // child entity const cookieKey2 =
 * datastore.key(['Customer', customerId1, 'Cookie', 'cookie78984']); // child
 * entity const cookieKey3 = datastore.key(['Customer', customerId2, 'Cookie',
 * 'cookie93911']); // child entity
 *
 * const entities = [];
 *
 * entities.push({
 *   key: customerKey1,
 *   data: {
 *     name: 'Jane Doe',
 *     address: '4848 Liller'
 *   }
 * });
 *
 * entities.push({
 *   key: customerKey2,
 *   data: {
 *     name: 'John Smith',
 *     address: '4848 Pine'
 *   }
 * });
 *
 * entities.push({
 *   key: cookieKey1,
 *   data: {
 *     cookieVal: 'dj83kks88rkld'
 *   }
 * });
 *
 * entities.push({
 *   key: cookieKey2,
 *   data: {
 *     cookieVal: 'sj843ka99s'
 *   }
 * });
 *
 * entities.push({
 *   key: cookieKey3,
 *   data: {
 *     cookieVal: 'otk82k2kw'
 *   }
 * });
 *
 * datastore.upsert(entities);
 *
 * const query = datastore.createQuery().hasAncestor(customerKey1);
 *
 * datastore.runQuery(query, (err, entities) => {
 *   for (let entity of entities) {
 *     console.log(entity[datastore.KEY]);
 *   }
 * });
 *
 * const query2 = datastore.createQuery().hasAncestor(customerKey2);
 *
 * datastore.runQuery(query2, (err, entities) => {
 *   for (let entity of entities) {
 *     console.log(entity[datastore.KEY]);
 *   }
 * });
 *
 * datastore.runQuery(query2, (entities) => {
 *   console.log(entities);
 * });
 * ```
 */
declare class Datastore extends DatastoreRequest {
    clients_: Map<string, ClientStub>;
    namespace?: string;
    defaultBaseUrl_: string;
    options: DatastoreOptions;
    baseUrl_?: string;
    port_?: number;
    customEndpoint_?: boolean;
    auth: GoogleAuth;
    constructor(options?: DatastoreOptions);
    /**
     * Export entities from this project to a Google Cloud Storage bucket.
     *
     * @param {ExportEntitiesConfig} config Configuration object.
     * @param {string | Bucket} config.bucket The `gs://bucket` path or a
     *     @google-cloud/storage Bucket object.
     * @param {string[]} [config.kinds] The kinds to include in this import.
     * @param {string[]} [config.namespaces] The namespace IDs to include in this
     *     import.
     * @param {object} [config.gaxOptions] Request configuration options, outlined
     *     here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request.
     * @param {Operation} callback.operation An operation object that can be used
     *     to check the status of the request.
     */
    export(config: ExportEntitiesConfig): Promise<LongRunningResponse>;
    export(config: ExportEntitiesConfig, callback: LongRunningCallback): void;
    /**
     * Get all of the indexes in this project.
     *
     * @param {GetIndexesOptions | GetIndexesCallback} [optionsOrCallback]
     * @param {object} [options.gaxOptions] Request configuration options,
     *     outlined here:
     *     https://googleapis.github.io/gax-nodejs/global.html#CallOptions.
     * @param {GetIndexesResponse} [callback] The callback function.
     * @param {?error} callback.error An error returned while making this request.
     * @param {Index[]} callback.indexes All matching Index instances.
     * @param {object} callback.apiResponse The full API response.
     * @return {void | Promise<GetIndexesResponse>}
     */
    getIndexes(options?: GetIndexesOptions): Promise<GetIndexesResponse>;
    getIndexes(options: GetIndexesOptions, callback: GetIndexesCallback): void;
    getIndexes(callback: GetIndexesCallback): void;
    /**
     * Get all of the indexes in this project as a readable object stream.
     *
     * @param {GetIndexesOptions} [options] Configuration object. See
     *     {@link Datastore#getIndexes} for a complete list of options.
     * @returns {ReadableStream<Index>}
     */
    getIndexesStream(options?: GetIndexesOptions): NodeJS.ReadableStream;
    getProjectId(): Promise<string>;
    /**
     * Import entities into this project from a remote file.
     *
     * @param {ImportEntitiesConfig} config Configuration object.
     * @param {string | File} config.file The `gs://bucket/file` path or a
     *     @google-cloud/storage File object.
     * @param {string[]} [config.kinds] The kinds to include in this import.
     * @param {string[]} [config.namespaces] The namespace IDs to include in this
     *     import.
     * @param {object} [config.gaxOptions] Request configuration options, outlined
     *     here: https://googleapis.github.io/gax-nodejs/global.html#CallOptions.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request.
     * @param {Operation} callback.operation An operation object that can be used
     *     to check the status of the request.
     */
    import(config: ImportEntitiesConfig): Promise<LongRunningResponse>;
    import(config: ImportEntitiesConfig, callback: LongRunningCallback): void;
    /**
     * Get a reference to an Index.
     *
     * @param {string} id The index name or id.
     * @returns {Index}
     */
    index(id: string): Index;
    /**
     * Maps to {@link Datastore#save}, forcing the method to be `insert`.
     *
     * @param {object|object[]} entities Datastore key object(s).
     * @param {Key} entities.key Datastore key object.
     * @param {string[]} [entities.excludeFromIndexes] Exclude properties from
     *     indexing using a simple JSON path notation. See the examples in
     *     {@link Datastore#save} to see how to target properties at different
     *     levels of nesting within your entity.
     * @param {object} entities.data Data to save with the provided key.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request
     * @param {object} callback.apiResponse The full API response.
     */
    insert(entities: Entities): Promise<InsertResponse>;
    insert(entities: Entities, callback: InsertCallback): void;
    /**
     * Insert or update the specified object(s). If a key is incomplete, its
     * associated object is inserted and the original Key object is updated to
     * contain the generated ID.
     *
     * This method will determine the correct Datastore method to execute
     * (`upsert`, `insert`, or `update`) by using the key(s) provided. For
     * example, if you provide an incomplete key (one without an ID), the request
     * will create a new entity and have its ID automatically assigned. If you
     * provide a complete key, the entity will be updated with the data specified.
     *
     * By default, all properties are indexed. To prevent a property from being
     * included in *all* indexes, you must supply an `excludeFromIndexes` array.
     *
     * To prevent large properties from being included in *all* indexes, you must supply
     * `excludeLargeProperties: true`.
     *  See below for an example.
     *
     * @borrows {@link Transaction#save} as save
     *
     * @throws {Error} If an unrecognized method is provided.
     *
     * @param {object|object[]} entities Datastore key object(s).
     * @param {Key} entities.key Datastore key object.
     * @param {string[]} [entities.excludeFromIndexes] Exclude properties from
     *     indexing using a simple JSON path notation. See the example below to
     * see how to target properties at different levels of nesting within your
     * @param {boolean} [entities.excludeLargeProperties] Automatically exclude
     *  large properties from indexing. It help in storing large values.
     * @param {string} [entities.method] Explicit method to use, either 'insert',
     *     'update', or 'upsert'.
     * @param {object} entities.data Data to save with the provided key.
     *     entity.
     * @param {object} [gaxOptions] Request configuration options, outlined here:
     *     https://googleapis.github.io/gax-nodejs/global.html#CallOptions.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request
     * @param {object} callback.apiResponse The full API response.
     *
     * @example
     * ```
     * //-
     * // Save a single entity.
     * //
     * // Notice that we are providing an incomplete key. After saving, the
     * // original Key object used to save will be updated to contain the path
     * // with its generated ID.
     * //-
     * const key = datastore.key('Company');
     * const entity = {
     *   key: key,
     *   data: {
     *     rating: '10'
     *   }
     * };
     *
     * datastore.save(entity, (err) => {
     *   console.log(key.path); // [ 'Company', 5669468231434240 ]
     *   console.log(key.namespace); // undefined
     * });
     *
     * //-
     * // Save a single entity using a provided name instead of auto-generated ID.
     * //
     * // Here we are providing a key with name instead of an ID. After saving,
     * // the original Key object used to save will be updated to contain the
     * // path with the name instead of a generated ID.
     * //-
     * const key = datastore.key(['Company', 'donutshack']);
     * const entity = {
     *   key: key,
     *   data: {
     *     name: 'DonutShack',
     *     rating: 8
     *   }
     * };
     *
     * datastore.save(entity, (err) => {
     *   console.log(key.path); // ['Company', 'donutshack']
     *   console.log(key.namespace); // undefined
     * });
     *
     * //-
     * // Save a single entity with a provided namespace. Namespaces allow for
     * // multitenancy. To read more about this, see
     * // [the Datastore docs on key concepts](https://goo.gl/M1LUAu).
     * //
     * // Here we are providing a key with namespace.
     * //-
     * const key = datastore.key({
     *   namespace: 'my-namespace',
     *   path: ['Company', 'donutshack']
     * });
     *
     * const entity = {
     *   key: key,
     *   data: {
     *     name: 'DonutShack',
     *     rating: 8
     *   }
     * };
     *
     * datastore.save(entity, (err) => {
     *   console.log(key.path); // ['Company', 'donutshack']
     *   console.log(key.namespace); // 'my-namespace'
     * });
     *
     * //-
     * // Save different types of data, including ints, doubles, dates, booleans,
     * // blobs, and lists.
     * //
     * // Notice that we are providing an incomplete key. After saving, the
     * // original Key object used to save will be updated to contain the path
     * // with its generated ID.
     * //-
     * const key = datastore.key('Company');
     * const entity = {
     *   key: key,
     *   data: {
     *     name: 'DonutShack',
     *     rating: datastore.int(10),
     *     worth: datastore.double(123456.78),
     *     location: datastore.geoPoint({
     *       latitude: 40.6894,
     *       longitude: -74.0447
     *     }),
     *     numDonutsServed: 45,
     *     founded: new Date('Tue May 12 2015 15:30:00 GMT-0400 (EDT)'),
     *     isStartup: true,
     *     donutEmoji: Buffer.from('\uD83C\uDF69'),
     *     keywords: [
     *       'donut',
     *       'coffee',
     *       'yum'
     *     ]
     *   }
     * };
     *
     * datastore.save(entity, (err, apiResponse) => {});
     *
     * //-
     * // Use an array, `excludeFromIndexes`, to exclude properties from indexing.
     * // This will allow storing string values larger than 1500 bytes.
     * //-
     * const entity = {
     *   key: datastore.key('Company'),
     *   excludeFromIndexes: [
     *     'description',
     *     'embeddedEntity.description',
     *     'arrayValue[]',
     *     'arrayValue[].description'
     *   ],
     *   data: {
     *     description: 'Long string (...)',
     *     embeddedEntity: {
     *       description: 'Long string (...)'
     *     },
     *     arrayValue: [
     *       'Long string (...)',
     *       {
     *         description: 'Long string (...)'
     *       }
     *     ]
     *   }
     * };
     *
     * datastore.save(entity, (err, apiResponse) => {});
     *
     * //-
     * // Use boolean `excludeLargeProperties`, to auto exclude Large properties from indexing.
     * // This will allow storing string values larger than 1500 bytes.
     * //-
     * const entity = {
     *   key: datastore.key('Company'),
     *   data: {
     *     description: 'Long string (...)',
     *     embeddedEntity: {
     *       description: 'Long string (...)'
     *     },
     *     arrayValue: [
     *       'Long string (...)',
     *       {
     *         description: 'Long string (...)'
     *       }
     *     ]
     *   },
     *   excludeLargeProperties: true
     * };
     *
     * datastore.save(entity, (err, apiResponse) => {});
     *
     * //-
     * // Save multiple entities at once.
     * //-
     * const companyKey = datastore.key(['Company', 123]);
     * const productKey = datastore.key(['Product', 'Computer']);
     * const entities = [
     *   {
     *     key: companyKey,
     *     data: {
     *       HQ: 'Dallas, TX'
     *     }
     *   },
     *   {
     *     key: productKey,
     *     data: {
     *       vendor: 'Dell'
     *     }
     *   }
     * ];
     *
     * datastore.save(entities, (err, apiResponse) => {});
     *
     * //-
     * // Explicitly attempt to 'insert' a specific entity.
     * //-
     * const userKey = datastore.key(['User', 'chilts']);
     * const entity = {
     *   key: userKey,
     *   method: 'insert',
     *   data: {
     *     fullName: 'Andrew Chilton'
     *   }
     * };
     *
     * datastore.save(entity, (err, apiResponse) => {});
     *
     * //-
     * // Returns a Promise if callback is omitted.
     * //-
     * datastore.save(entity).then((data) => {
     *   const apiResponse = data[0];
     * });
     * ```
     */
    save(entities: Entities, gaxOptions?: CallOptions): Promise<SaveResponse>;
    save(entities: Entities, gaxOptions: CallOptions, callback: SaveCallback): void;
    save(entities: Entities, callback: SaveCallback): void;
    /**
     * Maps to {@link Datastore#save}, forcing the method to be `update`.
     *
     * @param {object|object[]} entities Datastore key object(s).
     * @param {Key} entities.key Datastore key object.
     * @param {string[]} [entities.excludeFromIndexes] Exclude properties from
     *     indexing using a simple JSON path notation. See the examples in
     *     {@link Datastore#save} to see how to target properties at different
     *     levels of nesting within your entity.
     * @param {object} entities.data Data to save with the provided key.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request
     * @param {object} callback.apiResponse The full API response.
     */
    update(entities: Entities): Promise<UpdateResponse>;
    update(entities: Entities, callback: UpdateCallback): void;
    /**
     * Maps to {@link Datastore#save}, forcing the method to be `upsert`.
     *
     * @param {object|object[]} entities Datastore key object(s).
     * @param {Key} entities.key Datastore key object.
     * @param {string[]} [entities.excludeFromIndexes] Exclude properties from
     *     indexing using a simple JSON path notation. See the examples in
     *     {@link Datastore#save} to see how to target properties at different
     *     levels of nesting within your entity.
     * @param {object} entities.data Data to save with the provided key.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request
     * @param {object} callback.apiResponse The full API response.
     */
    upsert(entities: Entities): Promise<UpsertResponse>;
    upsert(entities: Entities, callback: UpsertCallback): void;
    /**
     * Helper function to get a Datastore Double object.
     *
     * @param {number} value The double value.
     * @returns {object}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const threeDouble = datastore.double(3.0);
     * ```
     */
    static double(value: number): entity.Double;
    double(value: number): entity.Double;
    /**
     * Helper function to check if something is a Datastore Double object.
     *
     * @param {*} value
     * @returns {boolean}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * datastore.isDouble(0.42); // false
     * datastore.isDouble(datastore.double(0.42)); // true
     * ```
     */
    static isDouble(value?: {}): boolean;
    isDouble(value?: {}): boolean;
    /**
     * Helper function to get a Datastore Geo Point object.
     *
     * @param {object} coordinates Coordinate value.
     * @param {number} coordinates.latitude Latitudinal value.
     * @param {number} coordinates.longitude Longitudinal value.
     * @returns {object}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const coordinates = {
     *   latitude: 40.6894,
     *   longitude: -74.0447
     * };
     *
     * const geoPoint = datastore.geoPoint(coordinates);
     *
     * //-
     * // List all companies that are located at 40.123 latitude
     * // and -74.0447 longitude.
     * //-
     * const query = datastore.createQuery('Company');
     * const companyQuery = query
     *   .filter('geoPoint.latitude', datastore.double(40.123))
     *   .filter('geoPoint.longitude', datastore.double(-74.0447));
     * ```
     */
    static geoPoint(coordinates: entity.Coordinates): entity.GeoPoint;
    geoPoint(coordinates: entity.Coordinates): entity.GeoPoint;
    /**
     * Helper function to check if something is a Datastore Geo Point object.
     *
     * @param {*} value
     * @returns {boolean}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const coordinates = {
     *   latitude: 0,
     *   longitude: 0
     * };
     *
     * datastore.isGeoPoint(coordinates); // false
     * datastore.isGeoPoint(datastore.geoPoint(coordinates)); // true
     * ```
     */
    static isGeoPoint(value?: {}): boolean;
    isGeoPoint(value?: {}): boolean;
    /**
     * Helper function to get a Datastore Integer object.
     *
     * This is also useful when using an ID outside the bounds of a JavaScript
     * Number object.
     *
     * @param {number} value The integer value.
     * @returns {object}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const sevenInteger = datastore.int(7);
     *
     * //-
     * // Create an Int to support long Key IDs.
     * //-
     * const key = datastore.key([
     *   'Kind',
     *   datastore.int('100000000000001234')
     * ]);
     * ```
     */
    static int(value: number | string): entity.Int;
    int(value: number | string): entity.Int;
    /**
     * Helper function to check if something is a Datastore Integer object.
     *
     * @param {*} value
     * @returns {boolean}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * datastore.isInt(42); // false
     * datastore.isInt(datastore.int(42)); // true
     * ```
     */
    static isInt(value?: {}): boolean;
    isInt(value?: {}): boolean;
    /**
     * Access the Key from an Entity object.
     *
     * @name Datastore.KEY
     * @type {symbol}
     */
    /**
     * Access the Key from an Entity object.
     *
     * @name Datastore#KEY
     * @type {symbol}
     */
    static KEY: typeof entity.KEY_SYMBOL;
    KEY: typeof entity.KEY_SYMBOL;
    /**
     * This is one of three values which may be returned from
     * {@link Datastore#runQuery}, {@link Transaction#runQuery}, and
     * {@link Query#run} as `info.moreResults`.
     *
     * There *may* be more results after the specified end cursor.
     *
     * @type {string}
     */
    static MORE_RESULTS_AFTER_CURSOR: string;
    MORE_RESULTS_AFTER_CURSOR: string;
    /**
     * This is one of three values which may be returned from
     * {@link Datastore#runQuery}, {@link Transaction#runQuery}, and
     * {@link Query#run} as `info.moreResults`.
     *
     * There *may* be more results after the specified limit.
     *
     * @type {string}
     */
    static MORE_RESULTS_AFTER_LIMIT: string;
    MORE_RESULTS_AFTER_LIMIT: string;
    /**
     * This is one of three values which may be returned from
     * {@link Datastore#runQuery}, {@link Transaction#runQuery}, and
     * {@link Query#run} as `info.moreResults`.
     *
     * There are no more results left to query for.
     *
     * @type {string}
     */
    static NO_MORE_RESULTS: string;
    NO_MORE_RESULTS: string;
    /**
     * Create a query for the specified kind. See {@link Query} for all
     * of the available methods.
     *
     * @see {@link https://cloud.google.com/datastore/docs/concepts/queries| Datastore Queries}
     * @see {@link Query}
     *
     * @param {string} [namespace] Namespace.
     * @param {string} kind  The kind to query.
     * @returns {Query}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const query = datastore.createQuery('Company');
     * ```
     */
    createQuery(kind?: string): Query;
    createQuery(kind?: string[]): Query;
    createQuery(namespace: string, kind: string): Query;
    createQuery(namespace: string, kind: string[]): Query;
    /**
     * Helper to create a Key object, scoped to the instance's namespace by
     * default.
     *
     * You may also specify a configuration object to define a namespace and path.
     *
     * @param {object|string|array} [options] Key path. To specify or override a namespace,
     *     you must use an object here to explicitly state it.
     * @param {string|array} [options.path]  Key path.
     * @param {string} [options.namespace] Optional namespace.
     * @returns {Key} A newly created Key from the options given.
     *
     * @example
     * ```
     * <caption>Create an incomplete key with a kind value of `Company`.
     * Since no Id is supplied, Datastore will generate one on save.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key('Company');
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key with a kind value of `Company` and Id `123`.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 123]);
     *
     * ```
     * @example
     * ```
     * <caption>If the ID integer is outside the bounds of a JavaScript Number
     * object, create an Int.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key([
     *   'Company',
     *   datastore.int('100000000000001234')
     * ]);
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key with a kind value of `Company` and name `Google`.
     * Because the supplied Id is a string, Datastore will prefix it with "name=".
     * Had the supplied Id been numeric, Datastore would prefix it with the standard, "id=".</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google']);
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key from a provided namespace and path.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key({
     *   namespace: 'My-NS',
     *   path: ['Company', 123]
     * });
     *
     * ```
     * @example
     * ```
     * <caption>Create a complete key that specifies an ancestor. This will create a Team entity
     * with a name of "Datastore", which belongs to the Company with the "name=Google" key.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google', 'Team', 'Datastore']);
     *
     * ```
     * @example
     * ```
     * <caption>Create a incomplete key that specifies an ancestor. This will create an Employee entity
     * with an auto-generated Id, which belongs to the Company with the "name=Google" key.</caption>
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google', 'Employee']);
     * ```
     */
    key(options: entity.KeyOptions): entity.Key;
    key(path: PathType[]): entity.Key;
    key(path: string): entity.Key;
    /**
     * Helper function to check if something is a Datastore Key object.
     *
     * @param {*} value
     * @returns {boolean}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * datastore.isKey({path: ['Company', 123]}); // false
     * datastore.isKey(datastore.key(['Company', 123])); // true
     * ```
     */
    static isKey(value?: {}): boolean;
    isKey(value?: {}): boolean;
    /**
     * Helper to create a URL safe key.
     *
     * This is intended to work with the "legacy" representation of a
     * datastore "Key" used within Google App Engine (a so-called "Reference").
     * The returned string can be used as the "urlsafe"
     * The base64 encoded values will have padding removed.
     *
     *
     * @param {entity.Key} key Entity key object.
     * @param {string} locationPrefix Optional .
     *  The location prefix of an App Engine project ID.
     *  Often this value is 's~', but may also be 'e~', or other location prefixes
     *  currently unknown.
     * @param {function} callback The callback function.
     * @param {?error} callback.err An error returned while making this request
     * @param {string} callback.urlSafeKey A Base64-encoded URL-safe key.
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const key = datastore.key(['Company', 'Google']);
     *
     * datastore.keyToLegacyUrlSafe(key, (err, urlSafeKey) => {
     *   if (err) {
     *     // Error handling omitted.
     *   }
     *   console.log(urlSafeKey);
     * });
     *
     * //-
     * // Create a complete URL-safe key using a location prefix.
     * //-
     * const locationPrefix = 's~';
     *
     * datastore.keyToLegacyUrlSafe(key, locationPrefix, (err, urlSafeKey) => {
     *   if (err) {
     *     // Error handling omitted.
     *   }
     *   console.log(urlSafeKey);
     * });
     *
     * //-
     * // If the callback is omitted, we'll return a Promise.
     * //-
     * datastore.keyToLegacyUrlSafe(key).then((data) => {
     *   const urlSafeKey = data[0];
     *   console.log(urlSafeKey);
     * });
     * ```
     */
    keyToLegacyUrlSafe(key: entity.Key, locationPrefix?: string): Promise<string>;
    keyToLegacyUrlSafe(key: entity.Key, callback: KeyToLegacyUrlSafeCallback): void;
    keyToLegacyUrlSafe(key: entity.Key, locationPrefix: string, callback: KeyToLegacyUrlSafeCallback): void;
    /**
     * Helper to convert URL safe key string to entity key object
     *
     * This is intended to work with the "legacy" representation of a
     * datastore "Key" used within Google App Engine (a so-called "Reference").
     *
     * @param {entity.Key} key Entity key object.
     * @param {string} locationPrefix Optional .
     *  The location prefix of an App Engine project ID.
     *  Often this value is 's~', but may also be 'e~', or other location prefixes
     *  currently unknown.
     * @returns {string} Created urlsafe key.
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const urlSafeKey = 'ag9ncmFzcy1jbHVtcC00NzlyEwsSB0NvbXBhbnkiBkdvb2dsZQw';
     *
     * datastore.keyFromLegacyUrlsafe(key);
     *
     * ```
     */
    keyFromLegacyUrlsafe(key: string): entity.Key;
    /**
     * Create a new Transaction object.
     *
     * @param {object} [options] Configuration object.
     * @param {string} [options.id] The ID of a previously run transaction.
     * @param {boolean} [options.readOnly=false] A read-only transaction cannot
     *     modify entities.
     * @returns {Transaction}
     *
     * @example
     * ```
     * const {Datastore} = require('@google-cloud/datastore');
     * const datastore = new Datastore();
     * const transaction = datastore.transaction();
     * ```
     */
    transaction(options?: TransactionOptions): Transaction;
    /**
     * Determine the appropriate endpoint to use for API requests. If not
     * explicitly defined, check for the "DATASTORE_EMULATOR_HOST" environment
     * variable, used to connect to a local Datastore server.
     *
     * @private
     *
     * @param {string} customApiEndpoint Custom API endpoint.
     */
    determineBaseUrl_(customApiEndpoint?: string): void;
    /**
     * {@link DatastoreRequest} class.
     *
     * @name Datastore.DatastoreRequest
     * @see DatastoreRequest
     * @type {constructor}
     */
    DatastoreRequest: typeof DatastoreRequest;
    /**
     * {@link Query} class.
     *
     * @name Datastore.Query
     * @see Query
     * @type {constructor}
     */
    Query: typeof Query;
    /**
     * {@link Transaction} class.
     *
     * @name Datastore.Transaction
     * @see Transaction
     * @type {constructor}
     */
    Transaction: typeof Transaction;
}
export { Datastore };
export interface TransactionOptions {
    id?: string;
    readOnly?: boolean;
}
export { Index, DatastoreRequest, Query, Transaction };
export interface DatastoreOptions extends GoogleAuthOptions {
    namespace?: string;
    apiEndpoint?: string;
    sslCreds?: ChannelCredentials;
}
export interface KeyToLegacyUrlSafeCallback {
    (err?: Error | null, urlSafeKey?: string): void;
}
declare const v1: any;
export { v1 };
export { DatastoreClient, DatastoreAdminClient } from './v1';