Initial import from local backup (Documents-Playground/pakerpale)

node_modules/googleapis-common/build/src/api.d.ts

@@ -0,0 +1,47 @@
+import { GaxiosOptions, GaxiosResponse } from 'gaxios';
+import { OAuth2Client } from 'google-auth-library';
+import { Endpoint } from './endpoint';
+export interface APIRequestParams<T = any> {
+    options: MethodOptions;
+    params: T;
+    requiredParams: string[];
+    pathParams: string[];
+    context: APIRequestContext;
+    mediaUrl?: string | null;
+}
+export interface GoogleConfigurable {
+    _options: GlobalOptions;
+}
+export interface APIRequestContext {
+    google?: GoogleConfigurable;
+    _options: GlobalOptions;
+}
+/**
+ * This interface is a mix of the AxiosRequestConfig options
+ * and our `auth: OAuth2Client|string` options.
+ */
+export interface GlobalOptions extends MethodOptions {
+    auth?: OAuth2Client | string;
+}
+export interface MethodOptions extends GaxiosOptions {
+    rootUrl?: string;
+    userAgentDirectives?: UserAgentDirective[];
+}
+/**
+ * An additional directive to add to the user agent header.
+ * Directives come in the form of:
+ * User-Agent: <product> / <product-version> <comment>
+ *
+ * For more information, see:
+ * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
+ */
+export interface UserAgentDirective {
+    product: string;
+    version: string;
+    comment?: string;
+}
+export interface ServiceOptions extends GlobalOptions {
+    version?: string;
+}
+export declare type BodyResponseCallback<T> = (err: Error | null, res?: GaxiosResponse<T> | null) => void;
+export declare type APIEndpoint = Readonly<Endpoint & any>;

node_modules/googleapis-common/build/src/api.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

node_modules/googleapis-common/build/src/apiIndex.d.ts

@@ -0,0 +1,4 @@
+import { GoogleConfigurable, ServiceOptions } from '.';
+export declare function getAPI<T>(api: string, options: ServiceOptions | string, versions: {
+    [index: string]: any;
+}, context?: GoogleConfigurable): T;

node_modules/googleapis-common/build/src/apiIndex.js

@@ -0,0 +1,40 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+function getAPI(api, options, 
+// tslint:disable-next-line no-any
+versions, context) {
+    let version;
+    if (typeof options === 'string') {
+        version = options;
+        options = {};
+    }
+    else if (typeof options === 'object') {
+        version = options.version;
+        delete options.version;
+    }
+    else {
+        throw new Error('Argument error: Accepts only string or object');
+    }
+    try {
+        const ctr = versions[version];
+        const ep = new ctr(options, context);
+        return Object.freeze(ep);
+    }
+    catch (e) {
+        throw new Error(`Unable to load endpoint ${api}("${version}"): ${e.message}`);
+    }
+}
+exports.getAPI = getAPI;
+//# sourceMappingURL=apiIndex.js.map

node_modules/googleapis-common/build/src/apirequest.d.ts

@@ -0,0 +1,9 @@
+import { GaxiosPromise } from 'gaxios';
+import { APIRequestParams, BodyResponseCallback } from './api';
+/**
+ * Create and send request to Google API
+ * @param parameters Parameters used to form request
+ * @param callback   Callback when request finished or error found
+ */
+export declare function createAPIRequest<T>(parameters: APIRequestParams): GaxiosPromise<T>;
+export declare function createAPIRequest<T>(parameters: APIRequestParams, callback: BodyResponseCallback<T>): void;

node_modules/googleapis-common/build/src/apirequest.js

@@ -0,0 +1,263 @@
+"use strict";
+// Copyright 2014-2016, Google, Inc.
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+const google_auth_library_1 = require("google-auth-library");
+const qs = require("qs");
+const stream = require("stream");
+const urlTemplate = require("url-template");
+const uuid = require("uuid");
+const extend = require("extend");
+const isbrowser_1 = require("./isbrowser");
+// tslint:disable-next-line no-var-requires
+const pkg = require('../../package.json');
+function isReadableStream(obj) {
+    return obj instanceof stream.Readable && typeof obj._read === 'function';
+}
+function getMissingParams(params, required) {
+    const missing = new Array();
+    required.forEach(param => {
+        // Is the required param in the params object?
+        if (params[param] === undefined) {
+            missing.push(param);
+        }
+    });
+    // If there are any required params missing, return their names in array,
+    // otherwise return null
+    return missing.length > 0 ? missing : null;
+}
+function createAPIRequest(parameters, callback) {
+    if (callback) {
+        createAPIRequestAsync(parameters).then(r => callback(null, r), callback);
+    }
+    else {
+        return createAPIRequestAsync(parameters);
+    }
+}
+exports.createAPIRequest = createAPIRequest;
+async function createAPIRequestAsync(parameters) {
+    let params = parameters.params;
+    const options = Object.assign({}, parameters.options);
+    // Create a new params object so it can no longer be modified from outside
+    // code Also support global and per-client params, but allow them to be
+    // overriden per-request
+    const topOptions = parameters.context.google &&
+        parameters.context.google._options &&
+        parameters.context.google._options.params
+        ? parameters.context.google._options.params
+        : {};
+    params = Object.assign({}, // New base object
+    topOptions, // Global params
+    parameters.context._options.params, // Per-client params
+    params // API call params
+    );
+    const media = params.media || {};
+    /**
+     * In a previous version of this API, the request body was stuffed in a field
+     * named `resource`.  This caused lots of problems, because it's not uncommon
+     * to have an actual named parameter required which is also named `resource`.
+     * This mean that users would have to use `resource_` in those cases, which
+     * pretty much nobody figures out on their own. The request body is now
+     * documented as being in the `requestBody` property, but we also need to keep
+     * using `resource` for reasons of back-compat. Cases that need to be covered
+     * here:
+     * - user provides just a `resource` with a request body
+     * - user provides both a `resource` and a `resource_`
+     * - user provides just a `requestBody`
+     * - user provides both a `requestBody` and a `resource`
+     */
+    const resource = params.requestBody ? params.requestBody : params.resource;
+    if (!params.requestBody && params.resource) {
+        delete params.resource;
+    }
+    delete params.requestBody;
+    let authClient = params.auth ||
+        parameters.context._options.auth ||
+        (parameters.context.google
+            ? parameters.context.google._options.auth
+            : null);
+    const defaultMime = typeof media.body === 'string' ? 'text/plain' : 'application/octet-stream';
+    delete params.media;
+    delete params.auth;
+    // Grab headers from user provided options
+    const headers = params.headers || {};
+    delete params.headers;
+    // Un-alias parameters that were modified due to conflicts with reserved names
+    Object.keys(params).forEach(key => {
+        if (key.slice(-1) === '_') {
+            const newKey = key.slice(0, -1);
+            params[newKey] = params[key];
+            delete params[key];
+        }
+    });
+    // Check for missing required parameters in the API request
+    const missingParams = getMissingParams(params, parameters.requiredParams);
+    if (missingParams) {
+        // Some params are missing - stop further operations and inform the
+        // developer which required params are not included in the request
+        throw new Error('Missing required parameters: ' + missingParams.join(', '));
+    }
+    // Parse urls
+    if (options.url) {
+        options.url = urlTemplate.parse(options.url).expand(params);
+    }
+    if (parameters.mediaUrl) {
+        parameters.mediaUrl = urlTemplate.parse(parameters.mediaUrl).expand(params);
+    }
+    // When forming the querystring, override the serializer so that array
+    // values are serialized like this:
+    // myParams: ['one', 'two'] ---> 'myParams=one&myParams=two'
+    // This serializer also encodes spaces in the querystring as `%20`,
+    // whereas the default serializer in gaxios encodes to a `+`.
+    options.paramsSerializer = params => {
+        return qs.stringify(params, { arrayFormat: 'repeat' });
+    };
+    // delete path parameters from the params object so they do not end up in
+    // query
+    parameters.pathParams.forEach(param => {
+        delete params[param];
+        if (parameters.context &&
+            parameters.context._options &&
+            parameters.context._options.params) {
+            delete parameters.context._options.params[param];
+        }
+    });
+    // if authClient is actually a string, use it as an API KEY
+    if (typeof authClient === 'string') {
+        params.key = params.key || authClient;
+        authClient = undefined;
+    }
+    if (parameters.mediaUrl && media.body) {
+        options.url = parameters.mediaUrl;
+        if (resource) {
+            // gaxios doesn't support multipart/related uploads, so it has to
+            // be implemented here.
+            params.uploadType = 'multipart';
+            const multipart = [
+                { 'Content-Type': 'application/json', body: JSON.stringify(resource) },
+                {
+                    'Content-Type': media.mimeType || (resource && resource.mimeType) || defaultMime,
+                    body: media.body,
+                },
+            ];
+            const boundary = uuid.v4();
+            const finale = `--${boundary}--`;
+            const rStream = new stream.PassThrough({
+                flush(callback) {
+                    this.push('\r\n');
+                    this.push(finale);
+                    callback();
+                },
+            });
+            const pStream = new ProgressStream();
+            const isStream = isReadableStream(multipart[1].body);
+            headers['Content-Type'] = `multipart/related; boundary=${boundary}`;
+            for (const part of multipart) {
+                const preamble = `--${boundary}\r\nContent-Type: ${part['Content-Type']}\r\n\r\n`;
+                rStream.push(preamble);
+                if (typeof part.body === 'string') {
+                    rStream.push(part.body);
+                    rStream.push('\r\n');
+                }
+                else {
+                    // Gaxios does not natively support onUploadProgress in node.js.
+                    // Pipe through the pStream first to read the number of bytes read
+                    // for the purpose of tracking progress.
+                    pStream.on('progress', bytesRead => {
+                        if (options.onUploadProgress) {
+                            options.onUploadProgress({ bytesRead });
+                        }
+                    });
+                    part.body.pipe(pStream).pipe(rStream);
+                }
+            }
+            if (!isStream) {
+                rStream.push(finale);
+                rStream.push(null);
+            }
+            options.data = rStream;
+        }
+        else {
+            params.uploadType = 'media';
+            Object.assign(headers, { 'Content-Type': media.mimeType || defaultMime });
+            options.data = media.body;
+        }
+    }
+    else {
+        options.data = resource || undefined;
+    }
+    options.headers = extend(true, options.headers || {}, headers);
+    options.params = params;
+    if (!isbrowser_1.isBrowser()) {
+        options.headers['Accept-Encoding'] = 'gzip';
+        const directives = options.userAgentDirectives || [];
+        directives.push({
+            product: 'google-api-nodejs-client',
+            version: pkg.version,
+            comment: 'gzip',
+        });
+        const userAgent = directives
+            .map(d => {
+            let line = `${d.product}/${d.version}`;
+            if (d.comment) {
+                line += ` (${d.comment})`;
+            }
+            return line;
+        })
+            .join(' ');
+        options.headers['User-Agent'] = userAgent;
+    }
+    // By default gaxios treats any 2xx as valid, and all non 2xx status
+    // codes as errors.  This is a problem for HTTP 304s when used along
+    // with an eTag.
+    if (!options.validateStatus) {
+        options.validateStatus = status => {
+            return (status >= 200 && status < 300) || status === 304;
+        };
+    }
+    // Retry by default
+    options.retry = options.retry === undefined ? true : options.retry;
+    // Combine the GaxiosOptions options passed with this specific
+    // API call witht the global options configured at the API Context
+    // level, or at the global level.
+    const mergedOptions = extend(true, {}, parameters.context.google ? parameters.context.google._options : {}, parameters.context._options, options);
+    delete mergedOptions.auth; // is overridden by our auth code
+    // Perform the HTTP request.  NOTE: this function used to return a
+    // mikeal/request object. Since the transition to Axios, the method is
+    // now void.  This may be a source of confusion for users upgrading from
+    // version 24.0 -> 25.0 or up.
+    if (authClient && typeof authClient === 'object') {
+        return authClient.request(mergedOptions);
+    }
+    else {
+        return new google_auth_library_1.DefaultTransporter().request(mergedOptions);
+    }
+}
+/**
+ * Basic Passthrough Stream that records the number of bytes read
+ * every time the cursor is moved.
+ */
+class ProgressStream extends stream.Transform {
+    constructor() {
+        super(...arguments);
+        this.bytesRead = 0;
+    }
+    // tslint:disable-next-line: no-any
+    _transform(chunk, encoding, callback) {
+        this.bytesRead += chunk.length;
+        this.emit('progress', this.bytesRead);
+        this.push(chunk);
+        callback();
+    }
+}
+//# sourceMappingURL=apirequest.js.map

node_modules/googleapis-common/build/src/authplus.d.ts

@@ -0,0 +1,6 @@
+import { Compute, GoogleAuth, JWT, OAuth2Client } from 'google-auth-library';
+export declare class AuthPlus extends GoogleAuth {
+    JWT: typeof JWT;
+    Compute: typeof Compute;
+    OAuth2: typeof OAuth2Client;
+}

node_modules/googleapis-common/build/src/authplus.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2019 Google LLC
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const google_auth_library_1 = require("google-auth-library");
+class AuthPlus extends google_auth_library_1.GoogleAuth {
+    constructor() {
+        super(...arguments);
+        // tslint:disable-next-line: variable-name
+        this.JWT = google_auth_library_1.JWT;
+        // tslint:disable-next-line: variable-name
+        this.Compute = google_auth_library_1.Compute;
+        // tslint:disable-next-line: variable-name
+        this.OAuth2 = google_auth_library_1.OAuth2Client;
+    }
+}
+exports.AuthPlus = AuthPlus;
+//# sourceMappingURL=authplus.js.map

node_modules/googleapis-common/build/src/discovery.d.ts

@@ -0,0 +1,42 @@
+import { GlobalOptions } from './api';
+import { Endpoint } from './endpoint';
+export declare type EndpointCreator = (options: GlobalOptions, google: {}) => Endpoint;
+export interface DiscoveryOptions {
+    includePrivate?: boolean;
+    debug?: boolean;
+}
+export declare class Discovery {
+    private transporter;
+    private options;
+    /**
+     * Discovery for discovering API endpoints
+     *
+     * @param options Options for discovery
+     */
+    constructor(options: DiscoveryOptions);
+    /**
+     * Generate and Endpoint from an endpoint schema object.
+     *
+     * @param schema The schema from which to generate the Endpoint.
+     * @return A function that creates an endpoint.
+     */
+    private makeEndpoint;
+    /**
+     * Log output of generator. Works just like console.log
+     */
+    private log;
+    /**
+     * Generate all APIs and return as in-memory object.
+     * @param discoveryUrl
+     */
+    discoverAllAPIs(discoveryUrl: string): Promise<{}>;
+    /**
+     * Generate API file given discovery URL
+     *
+     * @param apiDiscoveryUrl URL or filename of discovery doc for API
+     * @returns A promise that resolves with a function that creates the endpoint
+     */
+    discoverAPI(apiDiscoveryUrl: string | {
+        url: string;
+    }): Promise<EndpointCreator>;
+}

node_modules/googleapis-common/build/src/discovery.js

@@ -0,0 +1,145 @@
+"use strict";
+// Copyright 2014-2016, Google, Inc.
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const google_auth_library_1 = require("google-auth-library");
+const url = require("url");
+const util = require("util");
+const apirequest_1 = require("./apirequest");
+const endpoint_1 = require("./endpoint");
+const readFile = util.promisify(fs.readFile);
+class Discovery {
+    /**
+     * Discovery for discovering API endpoints
+     *
+     * @param options Options for discovery
+     */
+    constructor(options) {
+        this.transporter = new google_auth_library_1.DefaultTransporter();
+        this.options = options || {};
+    }
+    /**
+     * Generate and Endpoint from an endpoint schema object.
+     *
+     * @param schema The schema from which to generate the Endpoint.
+     * @return A function that creates an endpoint.
+     */
+    makeEndpoint(schema) {
+        return (options) => {
+            const ep = new endpoint_1.Endpoint(options);
+            ep.applySchema(ep, schema, schema, ep);
+            return ep;
+        };
+    }
+    /**
+     * Log output of generator. Works just like console.log
+     */
+    log(...args) {
+        if (this.options && this.options.debug) {
+            console.log(...args);
+        }
+    }
+    /**
+     * Generate all APIs and return as in-memory object.
+     * @param discoveryUrl
+     */
+    async discoverAllAPIs(discoveryUrl) {
+        const headers = this.options.includePrivate
+            ? {}
+            : { 'X-User-Ip': '0.0.0.0' };
+        const res = await this.transporter.request({
+            url: discoveryUrl,
+            headers,
+        });
+        const items = res.data.items;
+        const apis = await Promise.all(items.map(async (api) => {
+            const endpointCreator = await this.discoverAPI(api.discoveryRestUrl);
+            return { api, endpointCreator };
+        }));
+        const versionIndex = {};
+        // tslint:disable-next-line no-any
+        const apisIndex = {};
+        for (const set of apis) {
+            if (!apisIndex[set.api.name]) {
+                versionIndex[set.api.name] = {};
+                apisIndex[set.api.name] = (options) => {
+                    const type = typeof options;
+                    let version;
+                    if (type === 'string') {
+                        version = options;
+                        options = {};
+                    }
+                    else if (type === 'object') {
+                        version = options.version;
+                        delete options.version;
+                    }
+                    else {
+                        throw new Error('Argument error: Accepts only string or object');
+                    }
+                    try {
+                        const ep = 
+                        // tslint:disable-next-line: no-any
+                        set.endpointCreator(options, this);
+                        return Object.freeze(ep); // create new & freeze
+                    }
+                    catch (e) {
+                        throw new Error(util.format('Unable to load endpoint %s("%s"): %s', set.api.name, version, e.message));
+                    }
+                };
+            }
+            versionIndex[set.api.name][set.api.version] = set.endpointCreator;
+        }
+        return apisIndex;
+    }
+    /**
+     * Generate API file given discovery URL
+     *
+     * @param apiDiscoveryUrl URL or filename of discovery doc for API
+     * @returns A promise that resolves with a function that creates the endpoint
+     */
+    async discoverAPI(apiDiscoveryUrl) {
+        if (typeof apiDiscoveryUrl === 'string') {
+            const parts = url.parse(apiDiscoveryUrl);
+            if (apiDiscoveryUrl && !parts.protocol) {
+                this.log('Reading from file ' + apiDiscoveryUrl);
+                const file = await readFile(apiDiscoveryUrl, { encoding: 'utf8' });
+                return this.makeEndpoint(JSON.parse(file));
+            }
+            else {
+                this.log('Requesting ' + apiDiscoveryUrl);
+                const res = await this.transporter.request({
+                    url: apiDiscoveryUrl,
+                });
+                return this.makeEndpoint(res.data);
+            }
+        }
+        else {
+            const options = apiDiscoveryUrl;
+            this.log('Requesting ' + options.url);
+            const url = options.url;
+            delete options.url;
+            const parameters = {
+                options: { url, method: 'GET' },
+                requiredParams: [],
+                pathParams: [],
+                params: options,
+                context: { google: { _options: {} }, _options: {} },
+            };
+            const res = await apirequest_1.createAPIRequest(parameters);
+            return this.makeEndpoint(res.data);
+        }
+    }
+}
+exports.Discovery = Discovery;
+//# sourceMappingURL=discovery.js.map

node_modules/googleapis-common/build/src/endpoint.d.ts

@@ -0,0 +1,42 @@
+import { APIRequestContext, GlobalOptions } from './api';
+import { Schema, SchemaResource } from './schema';
+export interface Target {
+    [index: string]: {};
+}
+export declare class Endpoint implements Target, APIRequestContext {
+    _options: GlobalOptions;
+    google: any;
+    [index: string]: {};
+    constructor(options: {});
+    /**
+     * Given a schema, add methods and resources to a target.
+     *
+     * @param {object} target The target to which to apply the schema.
+     * @param {object} rootSchema The top-level schema, so we don't lose track of it
+     * during recursion.
+     * @param {object} schema The current schema from which to extract methods and
+     * resources.
+     * @param {object} context The context to add to each method.
+     */
+    applySchema(target: Target, rootSchema: Schema, schema: SchemaResource, context: APIRequestContext): void;
+    /**
+     * Given a schema, add methods to a target.
+     *
+     * @param {object} target The target to which to apply the methods.
+     * @param {object} rootSchema The top-level schema, so we don't lose track of it
+     * during recursion.
+     * @param {object} schema The current schema from which to extract methods.
+     * @param {object} context The context to add to each method.
+     */
+    private applyMethodsFromSchema;
+    /**
+     * Given a method schema, add a method to a target.
+     *
+     * @param target The target to which to add the method.
+     * @param schema The top-level schema that contains the rootUrl, etc.
+     * @param method The method schema from which to generate the method.
+     * @param context The context to add to the method.
+     */
+    private makeMethod;
+    private getPathParams;
+}

node_modules/googleapis-common/build/src/endpoint.js

@@ -0,0 +1,127 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+const apirequest_1 = require("./apirequest");
+class Endpoint {
+    constructor(options) {
+        this._options = options || {};
+    }
+    /**
+     * Given a schema, add methods and resources to a target.
+     *
+     * @param {object} target The target to which to apply the schema.
+     * @param {object} rootSchema The top-level schema, so we don't lose track of it
+     * during recursion.
+     * @param {object} schema The current schema from which to extract methods and
+     * resources.
+     * @param {object} context The context to add to each method.
+     */
+    applySchema(target, rootSchema, schema, context) {
+        this.applyMethodsFromSchema(target, rootSchema, schema, context);
+        if (schema.resources) {
+            for (const resourceName in schema.resources) {
+                if (schema.resources.hasOwnProperty(resourceName)) {
+                    const resource = schema.resources[resourceName];
+                    if (!target[resourceName]) {
+                        target[resourceName] = {};
+                    }
+                    this.applySchema(target[resourceName], rootSchema, resource, context);
+                }
+            }
+        }
+    }
+    /**
+     * Given a schema, add methods to a target.
+     *
+     * @param {object} target The target to which to apply the methods.
+     * @param {object} rootSchema The top-level schema, so we don't lose track of it
+     * during recursion.
+     * @param {object} schema The current schema from which to extract methods.
+     * @param {object} context The context to add to each method.
+     */
+    applyMethodsFromSchema(target, rootSchema, schema, context) {
+        if (schema.methods) {
+            for (const name in schema.methods) {
+                if (schema.methods.hasOwnProperty(name)) {
+                    const method = schema.methods[name];
+                    target[name] = this.makeMethod(rootSchema, method, context);
+                }
+            }
+        }
+    }
+    /**
+     * Given a method schema, add a method to a target.
+     *
+     * @param target The target to which to add the method.
+     * @param schema The top-level schema that contains the rootUrl, etc.
+     * @param method The method schema from which to generate the method.
+     * @param context The context to add to the method.
+     */
+    makeMethod(schema, method, context) {
+        return (paramsOrCallback, callback) => {
+            const params = typeof paramsOrCallback === 'function' ? {} : paramsOrCallback;
+            callback =
+                typeof paramsOrCallback === 'function'
+                    ? paramsOrCallback
+                    : callback;
+            const schemaUrl = buildurl(schema.rootUrl + schema.servicePath + method.path);
+            const parameters = {
+                options: {
+                    url: schemaUrl.substring(1, schemaUrl.length - 1),
+                    method: method.httpMethod,
+                },
+                params,
+                requiredParams: method.parameterOrder || [],
+                pathParams: this.getPathParams(method.parameters),
+                context,
+            };
+            if (method.mediaUpload &&
+                method.mediaUpload.protocols &&
+                method.mediaUpload.protocols.simple &&
+                method.mediaUpload.protocols.simple.path) {
+                const mediaUrl = buildurl(schema.rootUrl + method.mediaUpload.protocols.simple.path);
+                parameters.mediaUrl = mediaUrl.substring(1, mediaUrl.length - 1);
+            }
+            if (!callback) {
+                return apirequest_1.createAPIRequest(parameters);
+            }
+            apirequest_1.createAPIRequest(parameters, callback);
+            return;
+        };
+    }
+    getPathParams(params) {
+        const pathParams = new Array();
+        if (typeof params !== 'object') {
+            params = {};
+        }
+        Object.keys(params).forEach(key => {
+            if (params[key].location === 'path') {
+                pathParams.push(key);
+            }
+        });
+        return pathParams;
+    }
+}
+exports.Endpoint = Endpoint;
+/**
+ * Build a string used to create a URL from the discovery doc provided URL.
+ * replace double slashes with single slash (except in https://)
+ * @private
+ * @param  input URL to build from
+ * @return Resulting built URL
+ */
+function buildurl(input) {
+    return input ? `'${input}'`.replace(/([^:]\/)\/+/g, '$1') : '';
+}
+//# sourceMappingURL=endpoint.js.map

node_modules/googleapis-common/build/src/index.d.ts

@@ -0,0 +1,8 @@
+export { OAuth2Client } from 'google-auth-library';
+export { APIEndpoint, APIRequestContext, APIRequestParams, BodyResponseCallback, GlobalOptions, GoogleConfigurable, MethodOptions, ServiceOptions, } from './api';
+export { getAPI } from './apiIndex';
+export { createAPIRequest } from './apirequest';
+export { AuthPlus } from './authplus';
+export { Discovery, DiscoveryOptions, EndpointCreator } from './discovery';
+export { Endpoint, Target } from './endpoint';
+export { FragmentResponse, HttpMethod, ParameterFormat, Schema, SchemaItem, SchemaItems, SchemaMethod, SchemaMethods, SchemaParameter, SchemaParameters, SchemaResource, SchemaResources, Schemas, SchemaType, } from './schema';

node_modules/googleapis-common/build/src/index.js

@@ -0,0 +1,27 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+var google_auth_library_1 = require("google-auth-library");
+exports.OAuth2Client = google_auth_library_1.OAuth2Client;
+var apiIndex_1 = require("./apiIndex");
+exports.getAPI = apiIndex_1.getAPI;
+var apirequest_1 = require("./apirequest");
+exports.createAPIRequest = apirequest_1.createAPIRequest;
+var authplus_1 = require("./authplus");
+exports.AuthPlus = authplus_1.AuthPlus;
+var discovery_1 = require("./discovery");
+exports.Discovery = discovery_1.Discovery;
+var endpoint_1 = require("./endpoint");
+exports.Endpoint = endpoint_1.Endpoint;
+//# sourceMappingURL=index.js.map

node_modules/googleapis-common/build/src/isbrowser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * 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.
+ */
+export declare function isBrowser(): boolean;

node_modules/googleapis-common/build/src/isbrowser.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+exports.isBrowser = isBrowser;
+//# sourceMappingURL=isbrowser.js.map

node_modules/googleapis-common/build/src/schema.d.ts

@@ -0,0 +1,126 @@
+/**
+ * These are a collection of interfaces that represent the GoogleApis
+ * Discovery json formats.
+ */
+export interface Schemas {
+    discoveryVersion: string;
+    kind: string;
+    items: Schema[];
+}
+export interface Schema {
+    auth: {
+        oauth2: {
+            scopes: {
+                [index: string]: {
+                    description: string;
+                };
+            };
+        };
+    };
+    basePath: string;
+    baseUrl: string;
+    batchPath: string;
+    description: string;
+    discoveryVersion: string;
+    discoveryRestUrl: string;
+    documentationLink: string;
+    etag: string;
+    icons: {
+        x16: string;
+        x32: string;
+    };
+    id: string;
+    kind: string;
+    methods: SchemaMethods;
+    name: string;
+    ownerDomain: string;
+    ownerName: string;
+    parameters: SchemaParameters;
+    protocol: string;
+    resources: SchemaResources;
+    revision: string;
+    rootUrl: string;
+    schemas: SchemaItems;
+    servicePath: string;
+    title: string;
+    version: string;
+}
+export interface SchemaResources {
+    [index: string]: SchemaResource;
+}
+export interface SchemaResource {
+    methods?: SchemaMethods;
+    resources?: SchemaResources;
+}
+export interface SchemaItems {
+    [index: string]: SchemaItem;
+}
+export interface SchemaItem {
+    description?: string;
+    default?: string;
+    id?: string;
+    properties?: {
+        [index: string]: SchemaItem;
+    };
+    additionalProperties?: {
+        [index: string]: SchemaItem;
+    };
+    items?: {
+        [index: string]: SchemaItem;
+    };
+    type?: SchemaType;
+    format?: ParameterFormat;
+    $ref?: string;
+}
+export interface SchemaParameters {
+    [index: string]: SchemaParameter;
+}
+export interface SchemaParameter {
+    default: string;
+    description: string;
+    location: string;
+    enum: string[];
+    enumDescription: string[];
+    type: SchemaType;
+    format: ParameterFormat;
+    required: boolean;
+}
+export interface SchemaMethods {
+    [index: string]: SchemaMethod;
+}
+export interface SchemaMethod {
+    description: string;
+    httpMethod: HttpMethod;
+    id: string;
+    parameterOrder?: string[];
+    parameters?: {
+        [index: string]: SchemaParameter;
+    };
+    path: string;
+    request: {
+        $ref: string;
+    };
+    response: {
+        $ref: string;
+    };
+    sampleUrl: string;
+    scopes: string[];
+    fragment: string;
+    mediaUpload: {
+        protocols: {
+            simple: {
+                path: string;
+            };
+        };
+    };
+}
+export interface FragmentResponse {
+    codeFragment: {
+        [index: string]: {
+            fragment: string;
+        };
+    };
+}
+export declare type ParameterFormat = 'int32';
+export declare type HttpMethod = 'GET' | 'PATCH' | 'PUT';
+export declare type SchemaType = 'object' | 'integer' | 'string' | 'array' | 'boolean';

node_modules/googleapis-common/build/src/schema.js

@@ -0,0 +1,15 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map